[utilities] - C++11 → C++14

Files changed (1) hide show

tmp/tmphq8s8znw/{from.md → to.md} +1182 -519

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

@@ -12,10 +12,11 @@ C++standard library. These utilities are summarized in Table
 | Subclause             |                                  | Header               |
 | --------------------- | -------------------------------- | -------------------- |
 | [[utility]]           | Utility components               | `<utility>`          |
 | [[pairs]]             | Pairs                            | `<utility>`          |
 | [[tuple]]             | Tuples                           | `<tuple>`            |
 | [[template.bitset]]   | Fixed-size sequences of bits     | `<bitset>`           |
 |                       |                                  | `<memory>`           |
 | [[memory]]            | Memory                           | `<cstdlib>`          |
 |                       |                                  | `<cstring>`          |
 | [[smartptr]]          | Smart pointers                   | `<memory>`           |
@@ -53,63 +54,98 @@ namespace std {
   // [utility.swap], swap:
   template<class T> void swap(T& a, T& b) noexcept(see below);
   template <class T, size_t N> void swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b)));
   // [forward], forward/move:
-  template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;
-  template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept;
-  template <class T> typename remove_reference<T>::type&& move(T&&) noexcept;
-  template <class T> typename conditional<
     !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
-    const T&, T&&>::type move_if_noexcept(T& x) noexcept;
   // [declval], declval:
   template <class T>
- typename add_rvalue_reference<T>::type declval() noexcept;  // as unevaluated operand
   // [pairs], pairs:
   template <class T1, class T2> struct pair;
   // [pairs.spec], pair specialized algorithms:
   template <class T1, class T2>
-    bool operator==(const pair<T1,T2>&, const pair<T1,T2>&);
   template <class T1, class T2>
-    bool operator< (const pair<T1,T2>&, const pair<T1,T2>&);
   template <class T1, class T2>
-    bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&);
   template <class T1, class T2>
-    bool operator> (const pair<T1,T2>&, const pair<T1,T2>&);
   template <class T1, class T2>
-    bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&);
   template <class T1, class T2>
-    bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&);
   template <class T1, class T2>
     void swap(pair<T1,T2>& x, pair<T1,T2>& y) noexcept(noexcept(x.swap(y)));
   template <class T1, class T2>
-    see below make_pair(T1&&, T2&&);
   // [pair.astuple], tuple-like access to pair:
   template <class T> class tuple_size;
   template <size_t I, class T> class tuple_element;
-  template <class T1, class T2> struct tuple_size<std::pair<T1, T2> >;
-  template <class T1, class T2> struct tuple_element<0, std::pair<T1, T2> >;
-  template <class T1, class T2> struct tuple_element<1, std::pair<T1, T2> >;
   template<size_t I, class T1, class T2>
- typename tuple_element<I, std::pair<T1, T2> >::type& get(std::pair<T1, T2>&) noexcept;
   template<size_t I, class T1, class T2>
- typename tuple_element<I, std::pair<T1, T2> >::type&& get(std::pair<T1, T2>&&) noexcept;
   template<size_t I, class T1, class T2>
-    const typename tuple_element<I, std::pair<T1, T2> >::type&
-      get(const std::pair<T1, T2>&) noexcept;
   // [pair.piecewise], pair piecewise construction
   struct piecewise_construct_t { };
-  constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
   template <class... Types> class tuple;  // defined in <tuple>
 }
 ```
 ### Operators <a id="operators">[[operators]]</a>
@@ -185,24 +221,38 @@ template<class T, size_t N>
 *Requires:* `a[i]` shall be swappable with ([[swappable.requirements]])
 `b[i]` for all `i` in the range \[`0`, `N`).
 *Effects:* `swap_ranges(a, a + N, b)`
 ### forward/move helpers <a id="forward">[[forward]]</a>
 The library provides templated helper functions to simplify applying
 move semantics to an lvalue and to simplify the implementation of
 forwarding functions.
 ``` cpp
-template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;
-template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept;
 ```
 *Returns:* `static_cast<T&&>(t)`.
-if the second form is instantiated with an lvalue reference type, the
 program is ill-formed.
 ``` cpp
 template <class T, class A1, class A2>
 shared_ptr<T> factory(A1&& a1, A2&& a2) {
@@ -225,14 +275,14 @@ forwarded to `A`’s constructor as an rvalue. In the second call to
 `factory`, `A1` is deduced as `int&`, so `i` is forwarded to `A`’s
 constructor as an lvalue. In both cases, `A2` is deduced as `double`, so
 1.414 is forwarded to `A`’s constructor as an rvalue.
 ``` cpp
-template <class T> typename remove_reference<T>::type&& move(T&& t) noexcept;
 ```
-*Returns:* `static_cast<typename remove_reference<T>::type&&>(t)`.
 ``` cpp
 template <class T, class A1>
 shared_ptr<T> factory(A1&& a1) {
   return shared_ptr<T>(new T(std::forward<A1>(a1)));
@@ -257,13 +307,13 @@ forwarded as a non-const lvalue. This binds to the constructor
 `factory`, because of the call `std::move(a)`, `A1` is deduced as `A`,
 so `a` is forwarded as an rvalue. This binds to the constructor
 `A(A&&)`, which moves the value from `a`.
 ``` cpp
-template <class T> typename conditional<
   !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
-  const T&, T&&>::type move_if_noexcept(T& x) noexcept;
 ```
 *Returns:* `std::move(x)`
 ### Function template `declval` <a id="declval">[[declval]]</a>
@@ -272,11 +322,11 @@ The library provides the function template `declval` to simplify the
 definition of expressions which occur as unevaluated operands (Clause
 [[expr]]).
 ``` cpp
 template <class T>
- typename add_rvalue_reference<T>::type declval() noexcept;  // as unevaluated operand
 ```
 *Remarks:* If this function is odr-used ([[basic.def.odr]]), the
 program is ill-formed.
@@ -317,14 +367,14 @@ namespace std {
     T1 first;
     T2 second;
     pair(const pair&) = default;
     pair(pair&&) = default;
     constexpr pair();
-    pair(const T1& x, const T2& y);
-    template<class U, class V> pair(U&& x, V&& y);
-    template<class U, class V> pair(const pair<U, V>& p);
-    template<class U, class V> pair(pair<U, V>&& p);
     template <class... Args1, class... Args2>
       pair(piecewise_construct_t,
            tuple<Args1...> first_args, tuple<Args2...> second_args);
     pair& operator=(const pair& p);
@@ -335,14 +385,19 @@ namespace std {
     void swap(pair& p) noexcept(see below);
   };
 }
 ```
-Constructors and member function of `pair` shall not throw exceptions
 unless one of the element-wise operations specified to be called for
 that operation throws an exception.
 ``` cpp
 constexpr pair();
 ```
 *Requires:* `is_default_constructible<first_type>::value` is `true` and
@@ -350,21 +405,21 @@ constexpr pair();
 `ible<second_type>::value` is `true`.
 *Effects:* Value-initializes `first` and `second`.
 ``` cpp
-pair(const T1& x, const T2& y);
 ```
 *Requires:* `is_copy_constructible<first_type>::value` is `true` and
 `is_copy_constructible<second_type>::value` is `true`.
 *Effects:* The constructor initializes `first` with `x` and `second`
 with `y`.
 ``` cpp
-template<class U, class V> pair(U&& x, V&& y);
 ```
 *Requires:* `is_constructible<first_type, U&&>::value` is `true` and
 `is_constructible<second_type, V&&>::value` is `true`.
@@ -374,11 +429,11 @@ and `second` with `std::forward<V>(y)`.
 *Remarks:* If `U` is not implicitly convertible to `first_type` or `V`
 is not implicitly convertible to `second_type` this constructor shall
 not participate in overload resolution.
 ``` cpp
-template<class U, class V> pair(const pair<U, V>& p);
 ```
 *Requires:* `is_constructible<first_type, const U&>::value` is `true`
 and `is_constructible<second_type, const V&>::value` is `true`.
@@ -388,11 +443,11 @@ argument.
 This constructor shall not participate in overload resolution unless
 `const U&` is implicitly convertible to `first_type` and `const V&` is
 implicitly convertible to `second_type`.
 ``` cpp
-template<class U, class V> pair(pair<U, V>&& p);
 ```
 *Requires:* `is_constructible<first_type, U&&>::value` is `true` and
 `is_constructible<second_type, V&&>::value` is `true`.
@@ -408,13 +463,12 @@ convertible to `second_type`.
 template<class... Args1, class... Args2>
   pair(piecewise_construct_t,
        tuple<Args1...> first_args, tuple<Args2...> second_args);
 ```
-*Requires:* *Requires:*
-`is_constructible<first_type, Args1&&...>::value` is `true` and
-`is_constructible<second_type, Args2&&...>::value` is `true`.
 *Effects:* The constructor initializes `first` with arguments of types
 `Args1...` obtained by forwarding the elements of `first_args` and
 initializes `second` with arguments of types `Args2...` obtained by
 forwarding the elements of `second_args`. (Here, forwarding an element
@@ -436,12 +490,12 @@ pair& operator=(const pair& p);
 ``` cpp
 template<class U, class V> pair& operator=(const pair<U, V>& p);
 ```
-*Requires:* is_assignable\<first_type&, const U&\>::value is `true` and
-is_assignable\<second_type&, const V&\>::value is `true`.
 *Effects:* Assigns `p.first` to `first` and `p.second` to `second`.
 *Returns:* `*this`.
@@ -497,47 +551,47 @@ swappable with `p.second`.
 ### Specialized algorithms <a id="pairs.spec">[[pairs.spec]]</a>
 ``` cpp
 template <class T1, class T2>
-  bool operator==(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `x.first == y.first && x.second == y.second`.
 ``` cpp
 template <class T1, class T2>
-  bool operator<(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:*
 `x.first < y.first || (!(y.first < x.first) && x.second < y.second)`.
 ``` cpp
 template <class T1, class T2>
-  bool operator!=(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `!(x == y)`
 ``` cpp
 template <class T1, class T2>
-  bool operator>(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `y < x`
 ``` cpp
 template <class T1, class T2>
-  bool operator>=(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `!(x < y)`
 ``` cpp
 template <class T1, class T2>
-  bool operator<=(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `!(y < x)`
 ``` cpp
@@ -547,17 +601,17 @@ template<class T1, class T2> void swap(pair<T1, T2>& x, pair<T1, T2>& y)
 *Effects:* `x.swap(y)`
 ``` cpp
 template <class T1, class T2>
-  pair<V1, V2> make_pair(T1&& x, T2&& y);
 ```
 *Returns:* `pair<V1, V2>(std::forward<T1>(x), std::forward<T2>(y))`;
-where `V1` and `V2` are determined as follows: Let `Ui` be
-`decay<Ti>::type` for each `Ti`. Then each `Vi` is `X&` if `Ui` equals
 `reference_wrapper<X>`, otherwise `Vi` is `Ui`.
 In place of:
 ``` cpp
@@ -571,17 +625,15 @@ return make_pair(5, 3.1415926);           // types are deduced
 ```
 ### Tuple-like access to pair <a id="pair.astuple">[[pair.astuple]]</a>
 ``` cpp
-tuple_size<pair<T1, T2> >::value
 ```
-*Returns:* Integral constant expression.
-*Value:* 2.
 ``` cpp
 tuple_element<0, pair<T1, T2> >::type
 ```
 *Value:* the type `T1`.
@@ -592,32 +644,79 @@ tuple_element<1, pair<T1, T2> >::type
 *Value:* the type T2.
 ``` cpp
 template<size_t I, class T1, class T2>
- typename tuple_element<I, std::pair<T1, T2> >::type& get(pair<T1, T2>&) noexcept;
 template<size_t I, class T1, class T2>
-  const typename tuple_element<I, std::pair<T1, T2> >::type& get(const pair<T1, T2>&) noexcept;
 ```
 *Returns:* If `I == 0` returns `p.first`; if `I == 1` returns
 `p.second`; otherwise the program is ill-formed.
 ``` cpp
 template<size_t I, class T1, class T2>
- typename tuple_element<I, std::pair<T1, T2> >::type&& get(std::pair<T1, T2>&&) noexcept;
 ```
 *Returns:* If `I == 0` returns `std::forward<T1&&>(p.first)`; if
 `I == 1` returns `std::forward<T2&&>(p.second)`; otherwise the program
 is ill-formed.
 ### Piecewise construction <a id="pair.piecewise">[[pair.piecewise]]</a>
 ``` cpp
 struct piecewise_construct_t { };
-constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
 ```
 The `struct` `piecewise_construct_t` is an empty structure type used as
 a unique type to disambiguate constructor and function overloading.
 Specifically, `pair` has a constructor with `piecewise_construct_t` as
@@ -644,19 +743,19 @@ namespace std {
   // [tuple.creation], tuple creation functions:
   const unspecified ignore;
   template <class... Types>
-    tuple<VTypes...> make_tuple(Types&&...);
   template <class... Types>
-    tuple<Types...> forward_as_tuple(Types&&...) noexcept;
   template<class... Types>
-    tuple<Types&...> tie(Types&...) noexcept;
   template <class... Tuples>
-    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>;
@@ -669,31 +768,43 @@ namespace std {
   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...> >;
   // [tuple.elem], element access:
   template <size_t I, class... Types>
- typename tuple_element<I, tuple<Types...> >::type& get(tuple<Types...>&) noexcept;
-  template <size_t I, class... types>
-    typename tuple_element<I, tuple<Types...> >::type&& get(tuple<Types...>&&) noexcept;
-  template <size_t I, class... types>
-    typename tuple_element<I, tuple<Types...> >::type const& get(const tuple<Types...>&) noexcept;
   // [tuple.rel], relational operators:
   template<class... TTypes, class... UTypes>
-    bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
   template<class... TTypes, class... UTypes>
-    bool operator<(const tuple<TTypes...>&, const tuple<UTypes...>&);
   template<class... TTypes, class... UTypes>
-    bool operator!=(const tuple<TTypes...>&, const tuple<UTypes...>&);
   template<class... TTypes, class... UTypes>
-    bool operator>(const tuple<TTypes...>&, const tuple<UTypes...>&);
   template<class... TTypes, class... UTypes>
-    bool operator<=(const tuple<TTypes...>&, const tuple<UTypes...>&);
   template<class... TTypes, class... UTypes>
-    bool operator>=(const tuple<TTypes...>&, const tuple<UTypes...>&);
   // [tuple.traits], allocator-related traits
   template <class... Types, class Alloc>
     struct uses_allocator<tuple<Types...>, Alloc>;
@@ -711,26 +822,26 @@ namespace std {
   class tuple  {
   public:
     // [tuple.cnstr], tuple construction
     constexpr tuple();
-    explicit tuple(const Types&...);
     template <class... UTypes>
-      explicit tuple(UTypes&&...);
     tuple(const tuple&) = default;
     tuple(tuple&&) = default;
     template <class... UTypes>
-      tuple(const tuple<UTypes...>&);
     template <class... UTypes>
-      tuple(tuple<UTypes...>&&);
     template <class U1, class U2>
-      tuple(const pair<U1, U2>&);       // iff sizeof...(Types) == 2
     template <class U1, class U2>
-      tuple(pair<U1, U2>&&);            // iff sizeof...(Types) == 2
     // allocator-extended constructors
     template <class Alloc>
       tuple(allocator_arg_t, const Alloc& a);
     template <class Alloc>
@@ -758,13 +869,13 @@ namespace std {
       tuple& operator=(const tuple<UTypes...>&);
     template <class... UTypes>
       tuple& operator=(tuple<UTypes...>&&);
     template <class U1, class U2>
-      tuple& operator=(const pair<U1, U2>&);    // iff sizeof...(Types) == 2
     template <class U1, class U2>
-      tuple& operator=(pair<U1, U2>&&);         // iff sizeof...(Types) == 2
     // [tuple.swap], tuple swap
     void swap(tuple&) noexcept(see below);
   };
 }
@@ -773,10 +884,16 @@ namespace std {
 #### Construction <a id="tuple.cnstr">[[tuple.cnstr]]</a>
 For each `tuple` constructor, an exception is thrown only if the
 construction of one of the types in `Types` throws an exception.
 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.
@@ -787,21 +904,21 @@ constexpr tuple();
 *Requires:* `is_default_constructible<`Tᵢ`>::value` is true for all i.
 *Effects:* Value initializes each element.
 ``` cpp
-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>
-  explicit tuple(UTypes&&... u);
 ```
 *Requires:* `sizeof...(Types)` `==` `sizeof...(UTypes)`.
 `is_constructible<`Tᵢ`, `Uᵢ`&&>::value` is `true` for all i.
@@ -829,11 +946,11 @@ 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> tuple(const tuple<UTypes...>& u);
 ```
 *Requires:* `sizeof...(Types)` `==` `sizeof...(UTypes)`.
 `is_constructible<`Tᵢ`, const `Uᵢ`&>::value` is `true` for all i.
@@ -842,11 +959,11 @@ 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> tuple(tuple<UTypes...>&& u);
 ```
 *Requires:* `sizeof...(Types)` `==` `sizeof...(UTypes)`.
 `is_constructible<`Tᵢ`, `Uᵢ`&&>::value` is `true` for all i.
@@ -856,11 +973,11 @@ template <class... UTypes> tuple(tuple<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
-template <class U1, class U2> 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`
@@ -872,11 +989,11 @@ 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> 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
@@ -1025,11 +1142,11 @@ The expression inside `noexcept` is equivalent to the logical
 ``` 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
@@ -1046,14 +1163,14 @@ 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>
-  tuple<VTypes...> make_tuple(Types&&... t);
 ```
-Let Uᵢ be `decay<`Tᵢ`>::type` 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)...)`.
@@ -1068,11 +1185,11 @@ creates a tuple of type
 tuple<int, int&, const float&>
 ```
 ``` cpp
 template<class... Types>
-  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
@@ -1082,15 +1199,16 @@ named variable).
 *Returns:* `tuple<Types&&...>(std::forward<Types>(t)...)`
 ``` cpp
 template<class... Types>
-  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
@@ -1099,16 +1217,16 @@ tie(i, ignore, s) = make_tuple(42, 3.14, "C++");
 // i == 42, s == "C++"
 ```
 ``` cpp
 template <class... Tuples>
-  tuple<CTypes...> tuple_cat(Tuples&&... tpls);
 ```
 In the following paragraphs, let Tᵢ be the iᵗʰ type in `Tuples`, Uᵢ be
-`remove_reference<Ti>::type`, 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
@@ -1131,10 +1249,18 @@ eᵢ in order.
 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... Types>
 class tuple_size<tuple<Types...> >
   : public integral_constant<size_t, sizeof...(Types)> { };
 ```
@@ -1162,11 +1288,11 @@ 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<remove_cv<decltype(TS::value)>::type, 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>;
@@ -1176,31 +1302,30 @@ 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<`*`TE`*`::type>::type`,
-- for the second specialization, `add_volatile<`*`TE`*`::type>::type`,
-  and
-- for the third specialization, `add_cv<`*`TE`*`::type>::type`.
 #### Element access <a id="tuple.elem">[[tuple.elem]]</a>
 ``` cpp
 template <size_t I, class... Types>
- typename tuple_element<I, tuple<Types...> >::type& 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>
- typename tuple_element<I, tuple<Types...> >::type&& get(tuple<Types...>&& t) noexcept;
 ```
 *Effects:* Equivalent to
 `return std::forward<typename tuple_element<I, tuple<Types...> >`
 `::type&&>(get<I>(t));`
@@ -1209,11 +1334,11 @@ template <size_t I, class... types>
 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>
- typename tuple_element<I, tuple<Types...> >::type const& get(const tuple<Types...>& t) noexcept;
 ```
 *Requires:* `I < sizeof...(Types)`. The program is ill-formed if `I` is
 out of bounds.
@@ -1224,38 +1349,61 @@ 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.
 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>
-  bool operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 ```
-*Requires:* For all `i`, where `0 <= i` and `i < sizeof...(Types)`,
 `get<i>(t) == get<i>(u)` is a valid expression returning a type that is
 convertible to `bool`. `sizeof...(TTypes)` `==` `sizeof...(UTypes)`.
-*Returns:* `true` iff `get<i>(t) == get<i>(u)` for all `i`. 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>
-  bool operator<(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 ```
-*Requires:* For all `i`, where `0 <= i` and `i < sizeof...(Types)`,
 `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
@@ -1265,32 +1413,32 @@ where `r`ₜₐᵢₗ for some tuple `r` is a tuple containing all but the first
 element of `r`. For any two zero-length tuples `e` and `f`, `e < f`
 returns `false`.
 ``` cpp
 template<class... TTypes, class... UTypes>
-  bool operator!=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 ```
 *Returns:* `!(t == u)`.
 ``` cpp
 template<class... TTypes, class... UTypes>
-  bool operator>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 ```
 *Returns:* `u < t`.
 ``` cpp
 template<class... TTypes, class... UTypes>
-  bool operator<=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 ```
 *Returns:* `!(u < t)`
 ``` cpp
 template<class... TTypes, class... UTypes>
-  bool operator>=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 ```
 *Returns:* `!(t < u)`
 The above definitions for comparison operators do not require `tₜₐᵢₗ`
@@ -1326,10 +1474,62 @@ The expression inside `noexcept` is equivalent to:
 noexcept(x.swap(y))
 ```
 *Effects:* `x.swap(y)`
 ## Class template `bitset` <a id="template.bitset">[[template.bitset]]</a>
 \synopsis{Header \texttt{\<bitset\>} synopsis}
 ``` cpp
@@ -1415,11 +1615,11 @@ namespace std {
         class traits = char_traits<charT>,
         class Allocator = allocator<charT> >
       basic_string<charT, traits, Allocator>
       to_string(charT zero = charT('0'), charT one = charT('1')) const;
     size_t count() const noexcept;
-    constexpr size_t size() noexcept;
     bool operator==(const bitset<N>& rhs) const noexcept;
     bool operator!=(const bitset<N>& rhs) const noexcept;
     bool test(size_t pos) const;
     bool all() const noexcept;
     bool any() const noexcept;
@@ -1500,13 +1700,13 @@ position `pos` is other than `zero` or `one`. The function uses
 Otherwise, the function constructs an object of class `bitset<N>`,
 initializing the first `M` bit positions to values determined from the
 corresponding characters in the string `str`. `M` is the smaller of `N`
 and `rlen`.
-An element of the constructed string has value zero if the corresponding
-character in `str`, beginning at position `pos`, is `0` `zero`.
-Otherwise, the element has the value 1. Character position `pos + M - 1`
 corresponds to bit position zero. Subsequent decreasing character
 positions correspond to increasing bit positions.
 If `M < N`, remaining bit positions are initialized to zero.
@@ -1699,11 +1899,11 @@ size_t count() const noexcept;
 ```
 *Returns:* A count of the number of bits set in `*this`.
 ``` cpp
-constexpr size_t size() noexcept;
 ```
 *Returns:* `N`.
 ``` cpp
@@ -1760,11 +1960,11 @@ bitset<N> operator>>(size_t pos) const noexcept;
 ```
 *Returns:* `bitset<N>(*this) >>= pos`.
 ``` cpp
-constexpr bool operator[](size_t pos);
 ```
 *Requires:* `pos` shall be valid.
 *Returns:* `true` if the bit at position `pos` in `*this` has the value
@@ -1793,12 +1993,12 @@ entire underlying bitset.
 ``` cpp
 template <size_t N> struct hash<bitset<N> >;
 ```
-*Requires:* the template specialization shall meet the requirements of
-class template `hash` ([[unord.hash]]).
 ### `bitset` operators <a id="bitset.operators">[[bitset.operators]]</a>
 ``` cpp
 bitset<N> operator&(const bitset<N>& lhs, const bitset<N>& rhs) noexcept;
@@ -1863,20 +2063,20 @@ os << x.template to_string<charT,traits,allocator<charT> >(
 ### In general <a id="memory.general">[[memory.general]]</a>
 This subclause describes the contents of the header `<memory>` (
 [[memory.syn]]) and some of the contents of the C headers `<cstdlib>`
-and `cstring>` ([[c.malloc]]).
 ### Header `<memory>` synopsis <a id="memory.syn">[[memory.syn]]</a>
 The header `<memory>` defines several types and function templates that
 describe properties of pointers and pointer-like types, manage memory
 for containers and other template types, and construct multiple objects
 in uninitialized memory buffers ([[pointer.traits]]–
 [[specialized.algorithms]]). The header also defines the templates
-`unique_ptr`, `shared_ptr`, `weak_ptr`, and various template functions
 that operate on objects of these types ([[smartptr]]).
 ``` cpp
 namespace std {
   // [pointer.traits], pointer traits
@@ -1895,11 +2095,11 @@ namespace std {
   void* align(std::size_t alignment, std::size_t size,
     void*& ptr, std::size_t& space);
   // [allocator.tag], allocator argument tag
   struct allocator_arg_t { };
-  constexpr allocator_arg_t allocator_arg = allocator_arg_t();
   // [allocator.uses], uses_allocator
   template <class T, class Alloc> struct uses_allocator;
   // [allocator.traits], allocator traits
@@ -1940,10 +2140,16 @@ namespace std {
   template <class T> struct default_delete;
   template <class T> struct default_delete<T[]>;
   template <class T, class D = default_delete<T>> class unique_ptr;
   template <class T, class D> class unique_ptr<T[], D>;
   template <class T1, class D1, class T2, class D2>
     bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template <class T1, class D1, class T2, class D2>
     bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template <class T1, class D1, class T2, class D2>
@@ -1984,10 +2190,15 @@ namespace std {
   class bad_weak_ptr;
   // [util.smartptr.shared], class template shared_ptr:
   template<class T> class shared_ptr;
   // [util.smartptr.shared.cmp], shared_ptr comparisons:
   template<class T, class U>
     bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
   template<class T, class U>
     bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
@@ -2161,18 +2372,18 @@ arguments; otherwise, the instantiation of `rebind` is ill-formed.
 ``` cpp
 static pointer pointer_traits::pointer_to(see below r);
 static pointer pointer_traits<T*>::pointer_to(see below r) noexcept;
 ```
-if `element_type` is (possibly cv-qualified) `void`, the type of `r` is
 unspecified; otherwise, it is `element_type&`.
-*Returns:* The first member function returns a dereferenceable pointer
-to `r` obtained by calling `Ptr::pointer_to(r)`; an instantiation of
-this function is ill-formed if `Ptr` does not have a matching
-`pointer_to` static member function. The second member function returns
-`std::addressof(r)`.
 ### Pointer safety <a id="util.dynamic.safety">[[util.dynamic.safety]]</a>
 A complete object is *declared reachable* while the number of calls to
 `declare_reachable` with an argument referencing the object exceeds the
@@ -2223,15 +2434,15 @@ object must be live until the corresponding `undeclare_no_pointers()`
 call. In a garbage-collecting implementation, the fact that a region in
 an object is registered with `declare_no_pointers()` should not prevent
 the object from being collected.
 *Effects:* The `n` bytes starting at `p` no longer contain traceable
-pointer locations, independent of their type. Hence pointers located
-there may not be dereferenced if the object they point to was created by
-global `operator new` and not previously declared reachable. This may be
-used to inform a garbage collector or leak detector that this region of
-memory need not be traced.
 *Throws:* Nothing.
 Under some conditions implementations may need to allocate memory.
 However, the request can be ignored if memory allocation fails.
@@ -2288,11 +2499,11 @@ arguments for the same buffer.
 ### Allocator argument tag <a id="allocator.tag">[[allocator.tag]]</a>
 ``` cpp
 namespace std {
   struct allocator_arg_t { };
-  constexpr allocator_arg_t allocator_arg = allocator_arg_t();
 }
 ```
 The `allocator_arg_t` struct is an empty structure type used as a unique
 type to disambiguate constructor and function overloading. Specifically,
@@ -2386,11 +2597,11 @@ namespace std {
       static void construct(Alloc& a, T* p, Args&&... args);
     template <class T>
       static void destroy(Alloc& a, T* p);
-    static size_type max_size(const Alloc& a);
     static Alloc select_on_container_copy_construction(const Alloc& rhs);
   };
 }
 ```
@@ -2435,11 +2646,11 @@ typedef see below difference_type;
 ``` cpp
 typedef see below size_type;
 ```
 *Type:* `Alloc::size_type` if such a type exists; otherwise,
-`make_unsigned<difference_type>::type`.
 ``` cpp
 typedef see below propagate_on_container_copy_assignment;
 ```
@@ -2508,11 +2719,11 @@ template <class T>
 *Effects:* calls `a.destroy(p)` if that call is well-formed; otherwise,
 invokes `p->~T()`.
 ``` cpp
-static size_type max_size(Alloc& a);
 ```
 *Returns:* `a.max_size()` if that expression is well-formed; otherwise,
 `numeric_limits<size_type>::max()`.
@@ -2547,10 +2758,11 @@ namespace std {
     typedef const T*  const_pointer;
     typedef T&        reference;
     typedef const T&  const_reference;
     typedef T         value_type;
     template <class U> struct rebind { typedef allocator<U> other; };
     allocator() noexcept;
     allocator(const allocator&) noexcept;
     template <class U> allocator(const allocator<U>&) noexcept;
    ~allocator();
@@ -2622,11 +2834,12 @@ void deallocate(pointer p, size_type n);
 shall equal the value passed as the first argument to the invocation of
 allocate which returned `p`.
 *Effects:* Deallocates the storage referenced by `p` .
-*Remarks:* Uses `::operator delete(void*)` ([[new.delete]]), but it is
 unspecified when this function is called.
 ``` cpp
 size_type max_size() const noexcept;
 ```
@@ -2665,11 +2878,11 @@ template <class T1, class T2>
 *Returns:* `false`.
 ### Raw storage iterator <a id="storage.iterator">[[storage.iterator]]</a>
 `raw_storage_iterator` is provided to enable algorithms to store their
-results into uninitialized memory. The formal template parameter
 `OutputIterator` is required to have its `operator*` return an object
 for which `operator&` is defined and returns a pointer to `T`, and is
 also required to satisfy the requirements of an output iterator (
 [[output.iterators]]).
@@ -2679,14 +2892,14 @@ namespace std {
   class raw_storage_iterator
     : public iterator<output_iterator_tag,void,void,void,void> {
   public:
     explicit raw_storage_iterator(OutputIterator x);
-    raw_storage_iterator<OutputIterator,T>& operator*();
-    raw_storage_iterator<OutputIterator,T>& operator=(const T& element);
-    raw_storage_iterator<OutputIterator,T>& operator++();
-    raw_storage_iterator<OutputIterator,T>  operator++(int);
   };
 }
 ```
 ``` cpp
@@ -2695,33 +2908,33 @@ explicit raw_storage_iterator(OutputIterator x);
 *Effects:* Initializes the iterator to point to the same value to which
 `x` points.
 ``` cpp
-raw_storage_iterator<OutputIterator,T>& operator*();
 ```
 *Returns:* `*this`
 ``` cpp
-raw_storage_iterator<OutputIterator,T>& operator=(const T& element);
 ```
 *Effects:* Constructs a value from `element` at the location to which
 the iterator points.
 *Returns:* A reference to the iterator.
 ``` cpp
-raw_storage_iterator<OutputIterator,T>& operator++();
 ```
 *Effects:* Pre-increment: advances the iterator and returns a reference
 to the updated iterator.
 ``` cpp
-raw_storage_iterator<OutputIterator,T> operator++(int);
 ```
 *Effects:* Post-increment: advances the iterator and returns the old
 value of the iterator.
@@ -2749,22 +2962,21 @@ template <class T> void return_temporary_buffer(T* p);
 *Requires:* The buffer shall have been previously allocated by
 `get_temporary_buffer`.
 ### Specialized algorithms <a id="specialized.algorithms">[[specialized.algorithms]]</a>
-All the iterators that are used as formal template parameters in the
-following algorithms are required to have their `operator*` return an
-object for which `operator&` is defined and returns a pointer to `T`. In
-the algorithm `uninitialized_copy`, the formal template parameter
-`InputIterator` is required to satisfy the requirements of an input
-iterator ([[input.iterators]]). In all of the following algorithms, the
-formal template parameter `ForwardIterator` is required to satisfy the
-requirements of a forward iterator ([[forward.iterators]]), and is
-required to have the property that no exceptions are thrown from
-increment, assignment, comparison, or dereference of valid iterators. In
-the following algorithms, if an exception is thrown there are no
-effects.
 #### `addressof` <a id="specialized.addressof">[[specialized.addressof]]</a>
 ``` cpp
 template <class T> T* addressof(T& r) noexcept;
@@ -2928,10 +3140,14 @@ namespace std {
   template<class T> struct default_delete<T[]>;
   template<class T, class D = default_delete<T>> class unique_ptr;
   template<class T, class D> class unique_ptr<T[], D>;
   template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
   template<class T1, class D1, class T2, class D2>
     bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template<class T1, class D1, class T2, class D2>
@@ -3063,11 +3279,11 @@ namespace std {
     unique_ptr& operator=(unique_ptr&& u) noexcept;
     template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
     unique_ptr& operator=(nullptr_t) noexcept;
     // [unique.ptr.single.observers], observers
- typename add_lvalue_reference<T>::type operator*() const;
     pointer operator->() const noexcept;
     pointer get() const noexcept;
     deleter_type& get_deleter() noexcept;
     const deleter_type& get_deleter() const noexcept;
     explicit operator bool() const noexcept;
@@ -3093,16 +3309,14 @@ is valid and has the effect of disposing of the pointer as appropriate
 for that deleter.
 If the deleter’s type `D` is not a reference type, `D` shall satisfy the
 requirements of `Destructible` (Table  [[destructible]]).
-If the type `remove_reference<D>::type::pointer` exists, then
-`unique_ptr<T,
-D>::pointer` shall be a synonym for
-`remove_reference<D>::type::pointer`. Otherwise
-`unique_ptr<T, D>::pointer` shall be a synonym for `T*`. The type
-`unique_ptr<T,
 D>::pointer` shall satisfy the requirements of `NullablePointer` (
 [[nullablepointer.requirements]]).
 Given an allocator type `X` ([[allocator.requirements]]) and letting
 `A` be a synonym for `allocator_traits<X>`, the types `A::pointer`,
@@ -3298,18 +3512,17 @@ unique_ptr& operator=(unique_ptr&& u) noexcept;
 ```
 *Requires:* If `D` is not a reference type, `D` shall satisfy the
 requirements of `MoveAssignable` (Table  [[moveassignable]]) and
 assignment of the deleter from an rvalue of type `D` shall not throw an
-exception. Otherwise, `D` is a reference type;
-`remove_reference<D>::type` shall satisfy the `CopyAssignable`
-requirements and assignment of the deleter from an lvalue of type `D`
-shall not throw an exception.
 *Effects:* Transfers ownership from `u` to `*this` as if by calling
-`reset(u.release())` followed by an assignment from
-`std::forward<D>(u.get_deleter())`.
 *Returns:* `*this`.
 ``` cpp
 template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
@@ -3326,12 +3539,12 @@ unless:
 - `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer` and
 - `U` is not an array type.
 *Effects:* Transfers ownership from `u` to `*this` as if by calling
-`reset(u.release())` followed by an assignment from
-`std::forward<D>(u.get_deleter())`.
 *Returns:* `*this`.
 ``` cpp
 unique_ptr& operator=(nullptr_t) noexcept;
@@ -3344,11 +3557,11 @@ unique_ptr& operator=(nullptr_t) noexcept;
 *Returns:* `*this`.
 ##### `unique_ptr` observers <a id="unique.ptr.single.observers">[[unique.ptr.single.observers]]</a>
 ``` cpp
-typename add_lvalue_reference<T>::type operator*() const;
 ```
 *Requires:* `get() != nullptr`.
 *Returns:* `*get()`.
@@ -3507,18 +3720,41 @@ stored pointer points.
 *Returns:* `get()[i]`.
 ##### `unique_ptr` modifiers <a id="unique.ptr.runtime.modifiers">[[unique.ptr.runtime.modifiers]]</a>
 ``` cpp
-void reset(pointer p = pointer()) noexcept;
 void reset(nullptr_t p) noexcept;
 ```
-*Effects:* If `get() == nullptr` there are no effects. Otherwise
-`get_deleter()(get())`.
-`get() == p`.
 #### `unique_ptr` specialized algorithms <a id="unique.ptr.special">[[unique.ptr.special]]</a>
 ``` cpp
 template <class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
@@ -3680,12 +3916,12 @@ namespace std {
     // [util.smartptr.shared.const], constructors:
     constexpr shared_ptr() noexcept;
     template<class Y> explicit shared_ptr(Y* p);
     template<class Y, class D> shared_ptr(Y* p, D d);
     template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
-    template <class D> shared_ptr(nullptr_t p, D d)
-    template <class D, class A> shared_ptr(nullptr_t p, D d, A a)
     template<class Y> shared_ptr(const shared_ptr<Y>& r, T* p) noexcept;
     shared_ptr(const shared_ptr& r) noexcept;
     template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
     shared_ptr(shared_ptr&& r) noexcept;
     template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
@@ -3812,11 +4048,11 @@ races.
 constexpr shared_ptr() noexcept;
 ```
 *Effects:* Constructs an *empty* `shared_ptr` object.
-*Postconditions:* `use_count() == 0 && get() == 0`.
 ``` cpp
 template<class Y> explicit shared_ptr(Y* p);
 ```
@@ -3870,19 +4106,19 @@ template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p) noexcept;
 To avoid the possibility of a dangling pointer, the user of this
 constructor must ensure that `p` remains valid at least until the
 ownership group of `r` is destroyed.
 This constructor allows creation of an *empty* `shared_ptr` instance
-with a non-NULL stored pointer.
 ``` cpp
 shared_ptr(const shared_ptr& r) noexcept;
 template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
 ```
-*Requires:* The second constructor shall not participate in the overload
-resolution unless `Y*` is implicitly convertible to `T*`.
 *Effects:* If `r` is *empty*, constructs an *empty* `shared_ptr` object;
 otherwise, constructs a `shared_ptr` object that *shares ownership* with
 `r`.
@@ -3897,11 +4133,11 @@ The second constructor shall not participate in overload resolution
 unless `Y*` is convertible to `T*`.
 *Effects:* Move-constructs a `shared_ptr` instance from `r`.
 *Postconditions:* `*this` shall contain the old value of `r`. `r` shall
-be *empty*. `r.get() == 0.`
 ``` cpp
 template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
 ```
@@ -3925,11 +4161,11 @@ complete type. The expression `delete r.release()` shall be well formed,
 shall have well defined behavior, and shall not throw exceptions.
 *Effects:* Constructs a `shared_ptr` object that stores and *owns*
 `r.release()`.
-*Postconditions:* `use_count() == 1` `&&` `r.get() == 0`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory could not be obtained.
 If an exception is thrown, the constructor has no effect.
@@ -4082,11 +4318,11 @@ bool unique() const noexcept;
 *Returns:* `use_count() == 1`.
 `unique()` may be faster than `use_count()`. If you are using `unique()`
 to implement copy on write, do not rely on a specific value when
-`get() == 0`.
 ``` cpp
 explicit operator bool() const noexcept;
 ```
@@ -4132,13 +4368,13 @@ the newly constructed object of type `T`.
 *Postconditions:* `get() != 0 && use_count() == 1`
 *Throws:* `bad_alloc`, or an exception thrown from `A::allocate` or from
 the constructor of `T`.
-*Remarks:* Implementations are encouraged, but not required, to perform
-no more than one memory allocation. This provides efficiency equivalent
-to an intrusive smart pointer.
 These functions will typically allocate more memory than `sizeof(T)` to
 allow for internal bookkeeping structures such as the reference counts.
 ##### `shared_ptr` comparison <a id="util.smartptr.shared.cmp">[[util.smartptr.shared.cmp]]</a>
@@ -4152,11 +4388,11 @@ template<class T, class U> bool operator==(const shared_ptr<T>& a, const shared_
 ``` cpp
 template<class T, class U> bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
 ```
 *Returns:* `less<V>()(a.get(), b.get())`, where `V` is the composite
-pointer type ([[expr.rel]]) of `T*` and `U*`.
 Defining a comparison operator allows `shared_ptr` objects to be used as
 keys in associative containers.
 ``` cpp
@@ -4289,14 +4525,14 @@ undefined behavior, attempting to delete the same object twice.
 ``` cpp
 template<class D, class T> D* get_deleter(const shared_ptr<T>& p) noexcept;
 ```
 *Returns:* If `p` *owns* a deleter `d` of type cv-unqualified `D`,
-returns `&d`; otherwise returns `0`. The returned pointer remains valid
-as long as there exists a `shared_ptr` instance that owns `d`. It is
-unspecified whether the pointer remains valid longer than that. This can
-happen if the implementation doesn’t destroy the deleter until all
 `weak_ptr` instances that share ownership with `p` have been destroyed.
 ##### `shared_ptr` I/O <a id="util.smartptr.shared.io">[[util.smartptr.shared.io]]</a>
 ``` cpp
@@ -4323,29 +4559,33 @@ namespace std {
     // [util.smartptr.weak.const], constructors
     constexpr weak_ptr() noexcept;
     template<class Y> weak_ptr(shared_ptr<Y> const& r) noexcept;
     weak_ptr(weak_ptr const& r) noexcept;
     template<class Y> weak_ptr(weak_ptr<Y> const& r) noexcept;
     // [util.smartptr.weak.dest], destructor
     ~weak_ptr();
     // [util.smartptr.weak.assign], assignment
     weak_ptr& operator=(weak_ptr const& r) noexcept;
     template<class Y> weak_ptr& operator=(weak_ptr<Y> const& r) noexcept;
     template<class Y> weak_ptr& operator=(shared_ptr<Y> const& r) noexcept;
     // [util.smartptr.weak.mod], modifiers
     void swap(weak_ptr& r) noexcept;
     void reset() noexcept;
     // [util.smartptr.weak.obs], observers
     long use_count() const noexcept;
     bool expired() const noexcept;
     shared_ptr<T> lock() const noexcept;
-    template<class U> bool owner_before(shared_ptr<U> const& b);
-    template<class U> bool owner_before(weak_ptr<U> const& b);
   };
   // [util.smartptr.weak.spec], specialized algorithms
   template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 } // namespace std
@@ -4369,19 +4609,32 @@ constexpr weak_ptr() noexcept;
 weak_ptr(const weak_ptr& r) noexcept;
 template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept;
 template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
 ```
-*Requires:* The second and third constructors shall not participate in
-the overload resolution unless `Y*` is implicitly convertible to `T*`.
 *Effects:* If `r` is *empty*, constructs an *empty* `weak_ptr` object;
 otherwise, constructs a `weak_ptr` object that *shares ownership* with
 `r` and stores a copy of the pointer stored in `r`.
 *Postconditions:* `use_count() == r.use_count()`.
 ##### `weak_ptr` destructor <a id="util.smartptr.weak.dest">[[util.smartptr.weak.dest]]</a>
 ``` cpp
 ~weak_ptr();
 ```
@@ -4400,10 +4653,21 @@ template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
 *Effects:* Equivalent to `weak_ptr(r).swap(*this)`.
 *Remarks:* The implementation may meet the effects (and the implied
 guarantees) via different means, without creating a temporary.
 ##### `weak_ptr` modifiers <a id="util.smartptr.weak.mod">[[util.smartptr.weak.mod]]</a>
 ``` cpp
 void swap(weak_ptr& r) noexcept;
 ```
@@ -4437,15 +4701,16 @@ bool expired() const noexcept;
 ``` cpp
 shared_ptr<T> lock() const noexcept;
 ```
-*Returns:* `expired() ? shared_ptr<T>() : shared_ptr<T>(*this)`.
 ``` cpp
-template<class U> bool owner_before(shared_ptr<U> const& b);
-template<class U> bool owner_before(weak_ptr<U> const& b);
 ```
 *Returns:* An unspecified value such that
 - `x.owner_before(y)` defines a strict weak ordering as defined
@@ -4461,11 +4726,11 @@ template<class U> bool owner_before(weak_ptr<U> const& b);
 template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
-##### Class template `owner_less` <a id="util.smartptr.ownerless">[[util.smartptr.ownerless]]</a>
 The class template `owner_less` allows ownership-based mixed comparisons
 of shared and weak pointers.
 ``` cpp
@@ -4692,11 +4957,11 @@ template<class T>
 template<class T>
   bool atomic_compare_exchange_weak(
     shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
 ```
-*Requires:* `p` shall not be null.
 *Returns:*
 `atomic_compare_exchange_weak_explicit(p, v, w, memory_order_seq_cst, memory_order_seq_cst)`.
 *Throws:* Nothing.
@@ -4719,11 +4984,11 @@ template<class T>
   bool atomic_compare_exchange_strong_explicit(
     shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w,
     memory_order success, memory_order failure);
 ```
-*Requires:* `p` shall not be null.
 *Requires:* `failure` shall not be `memory_order_release`,
 `memory_order_acq_rel`, or stronger than `success`.
 *Effects:* If `*p` is equivalent to `*v`, assigns `w` to `*p` and has
@@ -4745,22 +5010,25 @@ See  [[atomics.types.operations]].
 ``` cpp
 template <class T, class D> struct hash<unique_ptr<T, D> >;
 ```
-*Requires:* The template specialization shall meet the requirements of
-class template `hash` ([[unord.hash]]). For an object `p` of type `UP`,
-where `UP` is `unique_ptr<T, D>`, `hash<UP>()(p)` shall evaluate to the
-same value as `hash<typename UP::pointer>()(p.get())`. The
-specialization `hash<typename UP::pointer>` shall be well-formed.
 ``` cpp
 template <class T> struct hash<shared_ptr<T> >;
 ```
-*Requires:* The template specialization shall meet the requirements of
-class template `hash` ([[unord.hash]]). For an object `p` of type
 `shared_ptr<T>`, `hash<shared_ptr<T> >()(p)` shall evaluate to the same
 value as `hash<T*>()(p.get())`.
 ## Function objects <a id="function.objects">[[function.objects]]</a>
@@ -4790,44 +5058,64 @@ namespace std {
   template <class T> reference_wrapper<T> ref(reference_wrapper<T>) noexcept;
   template <class T> reference_wrapper<const T> cref(reference_wrapper<T>) noexcept;
   // [arithmetic.operations], arithmetic operations:
-  template <class T> struct plus;
-  template <class T> struct minus;
-  template <class T> struct multiplies;
-  template <class T> struct divides;
-  template <class T> struct modulus;
-  template <class T> struct negate;
   // [comparisons], comparisons:
-  template <class T> struct equal_to;
-  template <class T> struct not_equal_to;
-  template <class T> struct greater;
-  template <class T> struct less;
-  template <class T> struct greater_equal;
-  template <class T> struct less_equal;
   // [logical.operations], logical operations:
-  template <class T> struct logical_and;
-  template <class T> struct logical_or;
-  template <class T> struct logical_not;
   // [bitwise.operations], bitwise operations:
-  template <class T> struct bit_and;
-  template <class T> struct bit_or;
-  template <class T> struct bit_xor;
   // [negators], negators:
   template <class Predicate> class unary_negate;
   template <class Predicate>
-    unary_negate<Predicate> not1(const Predicate&);
   template <class Predicate> class binary_negate;
   template <class Predicate>
-    binary_negate<Predicate> not2(const Predicate&);
-  // [bind], bind:
   template<class T> struct is_bind_expression;
   template<class T> struct is_placeholder;
   template<class F, class... BoundArgs>
     unspecified bind(F&&, BoundArgs&&...);
@@ -4889,34 +5177,10 @@ namespace std {
   template <class S, class T, class A>
     const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);
   // [func.memfn], member function adaptors:
   template<class R, class T> unspecified mem_fn(R T::*);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...));
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) const);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) volatile);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) const volatile);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) &);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) const &);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) volatile &);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) const volatile &);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) &&);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) const &&);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) volatile &&);
-  template<class R, class T, class... Args>
-    unspecified mem_fn(R (T::*)(Args...) const volatile &&);
   // [func.wrap] polymorphic function wrappers:
   class bad_function_call;
   template<class> class function; // undefined
@@ -4932,11 +5196,11 @@ namespace std {
   template<class R, class... ArgTypes>
     bool operator!=(const function<R(ArgTypes...)>&, nullptr_t);
   template<class R, class... ArgTypes>
     bool operator!=(nullptr_t, const function<R(ArgTypes...)>&);
-  // [unord.hash], hash function base template:
   template <class T> struct hash;
   // Hash function specializations
   template <> struct hash<bool>;
   template <> struct hash<char>;
@@ -4974,15 +5238,15 @@ To negate every element of `a`:
 ``` cpp
 transform(a.begin(), a.end(), a.begin(), negate<double>());
 ```
 To enable adaptors and other components to manipulate function objects
-that take one or two arguments it is required that the function objects
-correspondingly provide typedefs `argument_type` and `result_type` for
-function objects that take one argument and `first_argument_type`,
-`second_argument_type`, and `result_type` for function objects that take
-two arguments.
 ### Definitions <a id="func.def">[[func.def]]</a>
 The following definitions apply to this Clause:
@@ -5065,22 +5329,22 @@ namespace std {
     typedef see below second_argument_type;      // not always defined
     // construct/copy/destroy
     reference_wrapper(T&) noexcept;
     reference_wrapper(T&&) = delete;     // do not bind to temporary objects
-    reference_wrapper(const reference_wrapper<T>& x) noexcept;
     // assignment
-    reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
     // access
     operator T& () const noexcept;
     T& get() const noexcept;
     // invocation
     template <class... ArgTypes>
- typename result_of<T&(ArgTypes&&...)>::type
     operator() (ArgTypes&&...) const;
   };
 }
 ```
@@ -5089,11 +5353,11 @@ wrapper around a reference to an object or function of type `T`.
 `reference_wrapper<T>` has a weak result type ([[func.require]]). If
 `T` is a function type, `result_type` shall be a synonym for the return
 type of `T`.
-The template instantiation `reference_wrapper<T>` shall define a nested
 type named `argument_type` as a synonym for `T1` only if the type `T` is
 any of the following:
 - a function type or a pointer to function type taking one argument of
   type `T1`
@@ -5110,11 +5374,11 @@ the following:
 - a function type or a pointer to function type taking two arguments of
   types `T1` and `T2`
 - a pointer to member function `R T0::f(T2)` *cv* (where *cv* represents
   the member function’s cv-qualifiers); the type `T1` is *cv* `T0*`
 - a class type with member types `first_argument_type` and
-  `second_argument_type`; the type `T1` is `T::first_argument_type`. and
   the type `T2` is `T::second_argument_type`.
 #### `reference_wrapper` construct/copy/destroy <a id="refwrap.const">[[refwrap.const]]</a>
 ``` cpp
@@ -5123,20 +5387,20 @@ reference_wrapper(T& t) noexcept;
 *Effects:* Constructs a `reference_wrapper` object that stores a
 reference to `t`.
 ``` cpp
-reference_wrapper(const reference_wrapper<T>& x) noexcept;
 ```
 *Effects:* Constructs a `reference_wrapper` object that stores a
 reference to `x.get()`.
 #### `reference_wrapper` assignment <a id="refwrap.assign">[[refwrap.assign]]</a>
 ``` cpp
-reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
 ```
 *Postconditions:* `*this` stores a reference to `x.get()`.
 #### `reference_wrapper` access <a id="refwrap.access">[[refwrap.access]]</a>
@@ -5155,11 +5419,11 @@ T& get() const noexcept;
 #### reference_wrapper invocation <a id="refwrap.invoke">[[refwrap.invoke]]</a>
 ``` cpp
 template <class... ArgTypes>
- typename result_of<T&(ArgTypes&&... )>::type
     operator()(ArgTypes&&... args) const;
 ```
 *Returns:*
 *`INVOKE`*`(get(), std::forward<ArgTypes>(args)...)`. ([[func.require]])
@@ -5199,145 +5463,277 @@ template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexc
 The library provides basic function object classes for all of the
 arithmetic operators in the language ([[expr.mul]], [[expr.add]]).
 ``` cpp
-template <class T> struct plus {
-  T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x + y`.
 ``` cpp
-template <class T> struct minus {
-  T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x - y`.
 ``` cpp
-template <class T> struct multiplies {
-  T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x * y`.
 ``` cpp
-template <class T> struct divides {
-  T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x / y`.
 ``` cpp
-template <class T> struct modulus {
-  T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x % y`.
 ``` cpp
-template <class T> struct negate {
-  T operator()(const T& x) const;
   typedef T argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `-x`.
 ### Comparisons <a id="comparisons">[[comparisons]]</a>
 The library provides basic function object classes for all of the
 comparison operators in the language ([[expr.rel]], [[expr.eq]]).
 ``` cpp
-template <class T> struct equal_to {
-  bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x == y`.
 ``` cpp
-template <class T> struct not_equal_to {
-  bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x != y`.
 ``` cpp
-template <class T> struct greater {
-  bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x > y`.
 ``` cpp
-template <class T> struct less {
-  bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x < y`.
 ``` cpp
-template <class T> struct greater_equal {
-  bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x >= y`.
 ``` cpp
-template <class T> struct less_equal {
-  bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x <= y`.
 For templates `greater`, `less`, `greater_equal`, and `less_equal`, the
 specializations for any pointer type yield a total order, even if the
 built-in operators `<`, `>`, `<=`, `>=` do not.
 ### Logical operations <a id="logical.operations">[[logical.operations]]</a>
@@ -5345,111 +5741,198 @@ built-in operators `<`, `>`, `<=`, `>=` do not.
 The library provides basic function object classes for all of the
 logical operators in the language ([[expr.log.and]], [[expr.log.or]],
 [[expr.unary.op]]).
 ``` cpp
-template <class T> struct logical_and {
-  bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x && y`.
 ``` cpp
-template <class T> struct logical_or {
-  bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x || y`.
 ``` cpp
-template <class T> struct logical_not {
-  bool operator()(const T& x) const;
   typedef T argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `!x`.
 ### Bitwise operations <a id="bitwise.operations">[[bitwise.operations]]</a>
 The library provides basic function object classes for all of the
 bitwise operators in the language ([[expr.bit.and]], [[expr.or]],
-[[expr.xor]]).
 ``` cpp
-template <class T> struct bit_and {
-  T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x & y`.
 ``` cpp
-template <class T> struct bit_or {
-  T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x | y`.
 ``` cpp
-template <class T> struct bit_xor {
-  T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x ^ y`.
 ### Negators <a id="negators">[[negators]]</a>
 Negators `not1` and `not2` take a unary and a binary predicate,
 respectively, and return their complements ([[expr.unary.op]]).
 ``` cpp
 template <class Predicate>
   class unary_negate {
 public:
-  explicit unary_negate(const Predicate& pred);
-  bool operator()(const typename Predicate::argument_type& x) const;
   typedef typename Predicate::argument_type argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `!pred(x)`.
 ``` cpp
 template <class Predicate>
-  unary_negate<Predicate> not1(const Predicate& pred);
 ```
 *Returns:* `unary_negate<Predicate>(pred)`.
 ``` cpp
 template <class Predicate>
   class binary_negate {
   public:
-    explicit binary_negate(const Predicate& pred);
-    bool operator()(const typename Predicate::first_argument_type& x,
         const typename Predicate::second_argument_type& y) const;
   typedef typename Predicate::first_argument_type first_argument_type;
   typedef typename Predicate::second_argument_type second_argument_type;
   typedef bool result_type;
   };
@@ -5457,60 +5940,70 @@ template <class Predicate>
 `operator()` returns `!pred(x,y)`.
 ``` cpp
 template <class Predicate>
-  binary_negate<Predicate> not2(const Predicate& pred);
 ```
 *Returns:* `binary_negate<Predicate>(pred)`.
-### Function template `bind` <a id="bind">[[bind]]</a>
-The function template `bind` returns an object that binds a callable
-object passed as an argument to additional arguments.
-#### Function object binders <a id="func.bind">[[func.bind]]</a>
 This subclause describes a uniform mechanism for binding arguments of
 callable objects.
-##### Class template `is_bind_expression` <a id="func.bind.isbind">[[func.bind.isbind]]</a>
 ``` cpp
 namespace std {
-  template<class T> struct is_bind_expression
-    : integral_constant<bool, see below> { };
 }
 ```
 `is_bind_expression` can be used to detect function objects generated by
-`bind`. `bind` uses `is_bind_expression` to detect subexpressions. Users
-may specialize this template to indicate that a type should be treated
-as a subexpression in a `bind` call.
-If `T` is a type returned from `bind`, `is_bind_expression<T>` shall be
-publicly derived from `integral_constant<bool, true>`, otherwise from
-`integral_constant<bool, false>`.
 `is_placeholder` can be used to detect the standard placeholders `_1`,
 `_2`, and so on. `bind` uses `is_placeholder` to detect placeholders.
-Users may specialize this template to indicate a placeholder type.
-If `T` is the type of `std::placeholders::_J`, `is_placeholder<T>` shall
-be publicly derived from `integral_constant<int, J>`, otherwise from
-`integral_constant<int, 0>`.
-##### Function template `bind` <a id="func.bind.bind">[[func.bind.bind]]</a>
 In the text that follows, the following names have the following
 meanings:
-- `FD` is the type `decay<F>::type`,
 - `fd` is an lvalue of type `FD` constructed from `std::forward<F>(f)`,
-- `Ti` is the iᵗʰ type in the template parameter back `BoundArgs`,
-- `TiD` is the type `decay<Ti>::type`,
 - `ti` is the iᵗʰ argument in the function parameter pack `bound_args`,
 - `tid` is an lvalue of type `TiD` constructed from
   `std::forward<Ti>(ti)`,
 - `Uj` is the jᵗʰ deduced type of the `UnBoundArgs&&...` parameter of
   the forwarding call wrapper, and
@@ -5527,11 +6020,11 @@ template<class F, class... BoundArgs>
 expression for some values *w1, w2, ..., wN*, where
 `N == sizeof...(bound_args)`.
 *Returns:* A forwarding call wrapper `g` with a weak result
 type ([[func.require]]). The effect of `g(u1, u2, ..., uM)` shall be
-*`INVOKE`*`(fd, v1, v2, ..., vN, result_of<FD `*`cv`*` (V1, V2, ..., VN)>::type)`,
 where *`cv`* represents the *cv*-qualifiers of `g` and the values and
 types of the bound arguments `v1, v2, ..., vN` are determined as
 specified below. The copy constructor and move constructor of the
 forwarding call wrapper shall throw an exception if and only if the
 corresponding constructor of `FD` or of any of the types `TiD` throws an
@@ -5556,11 +6049,12 @@ template<class R, class F, class... BoundArgs>
 *`INVOKE`*`(fd, w1, w2, ..., wN)` shall be a valid expression for some
 values *w1, w2, ..., wN*, where `N == sizeof...(bound_args)`.
 *Returns:* A forwarding call wrapper `g` with a nested type
 `result_type` defined as a synonym for `R`. The effect of
-`g(u1, u2, ..., uM)` shall be *`INVOKE`*`(fd, v1, v2, ..., vN, R)`,
 where the values and types of the bound arguments `v1, v2, ..., vN` are
 determined as specified below. The copy constructor and move constructor
 of the forwarding call wrapper shall throw an exception if and only if
 the corresponding constructor of `FD` or of any of the types `TiD`
 throws an exception.
@@ -5581,16 +6075,16 @@ from the call to `bind` and the *cv*-qualifiers *cv* of the call wrapper
 - if `TiD` is `reference_wrapper<T>`, the argument is `tid.get()` and
   its type `Vi` is `T&`;
 - if the value of `is_bind_expression<TiD>::value` is `true`, the
   argument is `tid(std::forward<Uj>({}uj)...)` and its type `Vi` is
-  `result_of<TiD cv (Uj...)>::type`;
 - if the value `j` of `is_placeholder<TiD>::value` is not zero, the
   argument is `std::forward<Uj>(uj)` and its type `Vi` is `Uj&&`;
 - otherwise, the value is `tid` and its type `Vi` is `TiD cv &`.
-##### Placeholders <a id="func.bind.place">[[func.bind.place]]</a>
 ``` cpp
 namespace std {
   namespace placeholders {
     // M is the implementation-defined number of placeholders
@@ -5611,36 +6105,11 @@ whether placeholder types are `CopyAssignable`. `CopyAssignable`
 placeholders’ copy assignment operators shall not throw exceptions.
 ### Function template `mem_fn` <a id="func.memfn">[[func.memfn]]</a>
 ``` cpp
-template<class R, class T>
-  unspecified mem_fn(R T::* pm);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...));
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) volatile);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const volatile);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) &);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const &);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) volatile &);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const volatile &);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) &&);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const &&);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) volatile &&);
-template<class R, class T, class... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const volatile &&);
 ```
 *Returns:* A simple call wrapper ([[func.def]]) `fn` such that the
 expression `fn(t, a2, ..., aN)` is equivalent to
 *`INVOKE`*`(pm, t, a2, ..., aN)` ([[func.require]]). `fn` shall have a
@@ -5698,15 +6167,15 @@ namespace std {
   template<class R, class... ArgTypes>
   class function<R(ArgTypes...)> {
   public:
     typedef R result_type;
-    typedef T1 argument_type;           // iff sizeof...(ArgTypes) == 1 and
                                         // the type in ArgTypes is T1
-    typedef T1 first_argument_type;     // iff sizeof...(ArgTypes) == 2 and
                                         // ArgTypes contains T1 and T2
-    typedef T2 second_argument_type;    // iff sizeof...(ArgTypes) == 2 and
                                         // ArgTypes contains T1 and T2
     // [func.wrap.func.con], construct/copy/destroy:
     function() noexcept;
     function(nullptr_t) noexcept;
@@ -5740,12 +6209,12 @@ namespace std {
     // [func.wrap.func.inv], function invocation:
     R operator()(ArgTypes...) const;
     // [func.wrap.func.targ], function target access:
     const std::type_info& target_type() const noexcept;
-    template <typename T>       T* target() noexcept;
-    template <typename T> const T* target() const noexcept;
   };
   // [func.wrap.func.nullptr], Null pointer comparisons:
   template <class R, class... ArgTypes>
@@ -5834,20 +6303,21 @@ state with an unspecified value.
 ``` cpp
 template<class F> function(F f);
 template <class F, class A> function(allocator_arg_t, const A& a, F f);
 ```
-*Requires:* `F` shall be `CopyConstructible`. `f` shall be
-Callable ([[func.wrap.func]]) for argument types `ArgTypes` and return
-type `R`. The copy constructor and destructor of `A` shall not throw
-exceptions.
 *Postconditions:* `!*this` if any of the following hold:
-- `f` is a NULL function pointer.
-- `f` is a NULL pointer to member.
-- `F` is an instance of the `function` class template, and `!f`
 Otherwise, `*this` targets a copy of `f` initialized with
 `std::move(f)`. Implementations are encouraged to avoid the use of
 dynamically allocated memory for small callable objects, for example,
 where `f`’s target is an object holding only a pointer or reference to
@@ -5875,11 +6345,11 @@ function& operator=(function&& f);
 ``` cpp
 function& operator=(nullptr_t);
 ```
-*Effects:* If `*this != NULL`, destroys the target of `this`.
 *Postconditions:* `!(*this)`.
 *Returns:* `*this`
@@ -5889,10 +6359,15 @@ template<class F> function& operator=(F&& f);
 *Effects:* `function(std::forward<F>(f)).swap(*this);`
 *Returns:* `*this`
 ``` cpp
 template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ```
 *Effects:* `function(f).swap(*this);`
@@ -5901,11 +6376,11 @@ template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ``` cpp
 ~function();
 ```
-*Effects:* If `*this != NULL`, destroys the target of `this`.
 ##### `function` modifiers <a id="func.wrap.func.mod">[[func.wrap.func.mod]]</a>
 ``` cpp
 void swap(function& other) noexcept;
@@ -5952,18 +6427,18 @@ const std::type_info& target_type() const noexcept;
 *Returns:* If `*this` has a target of type `T`, `typeid(T)`; otherwise,
 `typeid(void)`.
 ``` cpp
-template<typename T>       T* target() noexcept;
-template<typename T> const T* target() const noexcept;
 ```
 *Requires:* `T` shall be a type that is Callable ([[func.wrap.func]])
 for parameter types `ArgTypes` and return type `R`.
-*Returns:* If `target_`type() == typeid(T) a pointer to the stored
 function target; otherwise a null pointer.
 ##### null pointer comparison operators <a id="func.wrap.func.nullptr">[[func.wrap.func.nullptr]]</a>
 ``` cpp
@@ -5996,11 +6471,12 @@ template<class R, class... ArgTypes>
 ### Class template `hash` <a id="unord.hash">[[unord.hash]]</a>
 The unordered associative containers defined in [[unord]] use
 specializations of the class template `hash` as the default hash
 function. For all object types `Key` for which there exists a
-specialization `hash<Key>`, the instantiation `hash<Key>` shall:
 - satisfy the `Hash` requirements ([[hash.requirements]]), with `Key`
   as the function call argument type, the `DefaultConstructible`
   requirements (Table  [[defaultconstructible]]), the `CopyAssignable`
   requirements (Table  [[copyassignable]]),
@@ -6035,12 +6511,12 @@ template <> struct hash<float>;
 template <> struct hash<double>;
 template <> struct hash<long double>;
 template <class T> struct hash<T*>;
 ```
-*Requires:* the template specializations shall meet the requirements of
-class template `hash` ([[unord.hash]]).
 ## Metaprogramming and type traits <a id="meta">[[meta]]</a>
 This subclause describes components used by C++programs, particularly in
 templates, to support the widest possible range of types, optimise
@@ -6081,12 +6557,12 @@ shall not be hidden and shall be unambiguously available in the
 BinaryTypeTrait.
 A *TransformationTrait* modifies a property of a type. It shall be a
 class template that takes one template type argument and, optionally,
 additional arguments that help define the modification. It shall define
-a nested type named `type`, which shall be a synonym for the modified
-type.
 ### Header `<type_traits>` synopsis <a id="meta.type.synop">[[meta.type.synop]]</a>
 ``` cpp
 namespace std {
@@ -6095,10 +6571,11 @@ namespace std {
   typedef integral_constant<bool, true>  true_type;
   typedef integral_constant<bool, false> false_type;
   // [meta.unary.cat], primary type categories:
   template <class T> struct is_void;
   template <class T> struct is_integral;
   template <class T> struct is_floating_point;
   template <class T> struct is_array;
   template <class T> struct is_pointer;
   template <class T> struct is_lvalue_reference;
@@ -6128,10 +6605,11 @@ namespace std {
   template <class T> struct is_pod;
   template <class T> struct is_literal_type;
   template <class T> struct is_empty;
   template <class T> struct is_polymorphic;
   template <class T> struct is_abstract;
   template <class T> struct is_signed;
   template <class T> struct is_unsigned;
   template <class T, class... Args> struct is_constructible;
@@ -6183,27 +6661,62 @@ namespace std {
   template <class T> struct remove_cv;
   template <class T> struct add_const;
   template <class T> struct add_volatile;
   template <class T> struct add_cv;
   // [meta.trans.ref], reference modifications:
   template <class T> struct remove_reference;
   template <class T> struct add_lvalue_reference;
   template <class T> struct add_rvalue_reference;
   // [meta.trans.sign], sign modifications:
   template <class T> struct make_signed;
   template <class T> struct make_unsigned;
   // [meta.trans.arr], array modifications:
   template <class T> struct remove_extent;
   template <class T> struct remove_all_extents;
   // [meta.trans.ptr], pointer modifications:
   template <class T> struct remove_pointer;
   template <class T> struct add_pointer;
   // [meta.trans.other], other transformations:
   template <std::size_t Len,
             std::size_t Align = default-alignment>   // see [meta.trans.other]
     struct aligned_storage;
   template <std::size_t Len, class... Types> struct aligned_union;
@@ -6212,10 +6725,28 @@ namespace std {
   template <bool, class T, class F> struct conditional;
   template <class... T> struct common_type;
   template <class T> struct underlying_type;
   template <class> class result_of;   // not defined
   template <class F, class... ArgTypes> class result_of<F(ArgTypes...)>;
 } // namespace std
 ```
 The behavior of a program that adds specializations for any of the class
 templates defined in this subclause is undefined unless otherwise
@@ -6228,11 +6759,12 @@ namespace std {
   template <class T, T v>
   struct integral_constant {
     static constexpr T value = v;
     typedef T value_type;
     typedef integral_constant<T,v> type;
-    constexpr operator value_type() { return value; }
   };
   typedef integral_constant<bool, true> true_type;
   typedef integral_constant<bool, false> false_type;
 }
 ```
@@ -6291,21 +6823,34 @@ is_const<const int&>::value             // false
 is_const<int[3]>::value                 // false
 is_const<const int[3]>::value           // true
 ```
 ``` cpp
-remove_const<const volatile int>::type  // volatile int
-remove_const<const int* const>::type    // const int*
-remove_const<const int&>::type          // const int&
-remove_const<const int[3]>::type        // int[3]
 ```
 Given the following function prototype:
 ``` cpp
 template <class T>
- typename add_rvalue_reference<T>::type create();
 ```
 the predicate condition for a template specialization
 `is_constructible<T, Args...>` shall be satisfied if and only if the
 following variable definition would be well-formed for some invented
@@ -6327,10 +6872,13 @@ the “immediate context” and can result in the program being ill-formed.
 ### Type property queries <a id="meta.unary.prop.query">[[meta.unary.prop.query]]</a>
 This sub-clause contains templates that may be used to query properties
 of types at compile time.
 ``` cpp
 // the following assertions hold:
 assert(rank<int>::value == 0);
 assert(rank<int[2]>::value == 1);
 assert(rank<int[][4]>::value == 2);
@@ -6375,11 +6923,11 @@ is_base_of<int, int>::value     // false
 Given the following function prototype:
 ``` cpp
 template <class T>
- typename add_rvalue_reference<T>::type create();
 ```
 the predicate condition for a template specialization
 `is_convertible<From, To>` shall be satisfied if and only if the return
 expression in the following code would be well-formed, including any
@@ -6418,22 +6966,22 @@ Each of the templates in this subclause shall be a
 #### Array modifications <a id="meta.trans.arr">[[meta.trans.arr]]</a>
 ``` cpp
 // the following assertions hold:
-assert((is_same<remove_extent<int>::type, int>::value));
-assert((is_same<remove_extent<int[2]>::type, int>::value));
-assert((is_same<remove_extent<int[2][3]>::type, int[3]>::value));
-assert((is_same<remove_extent<int[][3]>::type, int[3]>::value));
 ```
 ``` cpp
 // the following assertions hold:
-assert((is_same<remove_all_extents<int>::type, int>::value));
-assert((is_same<remove_all_extents<int[2]>::type, int>::value));
-assert((is_same<remove_all_extents<int[2][3]>::type, int>::value));
-assert((is_same<remove_all_extents<int[][3]>::type, int>::value));
 ```
 #### Pointer modifications <a id="meta.trans.ptr">[[meta.trans.ptr]]</a>
 #### Other transformations <a id="meta.trans.other">[[meta.trans.other]]</a>
@@ -6457,21 +7005,21 @@ The nested typedef `common_type::type` shall be defined as follows:
 ``` cpp
 template <class ...T> struct common_type;
 template <class T>
 struct common_type<T> {
-  typedef T type;
 };
 template <class T, class U>
 struct common_type<T, U> {
-  typedef decltype(true ? declval<T>() : declval<U>()) type;
 };
 template <class T, class U, class... V>
 struct common_type<T, U, V...> {
-  typedef typename common_type<typename common_type<T, U>::type, V...>::type type;
 };
 ```
 Given these definitions:
@@ -6491,16 +7039,16 @@ typedef char S::*PMD;
 ```
 the following assertions will hold:
 ``` cpp
-static_assert(is_same<result_of<S(int)>::type, short>::value, "Error!");
-static_assert(is_same<result_of<S&(unsigned char, int&)>::type, double>::value, "Error!");
-static_assert(is_same<result_of<PF1()>::type, bool>::value, "Error!");
-static_assert(is_same<result_of<PMF(unique_ptr<S>, int)>::type, void>::value, "Error!");
-static_assert(is_same<result_of<PMD(S)>::type, char&&>::value, "Error!");
-static_assert(is_same<result_of<PMD(const S*)>::type, const char&>::value, "Error!");
 ```
 ## Compile-time rational arithmetic <a id="ratio">[[ratio]]</a>
 ### In general <a id="ratio.general">[[ratio.general]]</a>
@@ -6508,13 +7056,14 @@ static_assert(is_same<result_of<PMD(const S*)>::type, const char&>::value, "Erro
 This subclause describes the ratio library. It provides a class template
 `ratio` which exactly represents any finite rational number with a
 numerator and denominator representable by compile-time constants of
 type `intmax_t`.
-Throughout this subclause, if the template argument types `R1` and `R2`
-are not specializations of the `ratio` template, the program is
-ill-formed.
 ### Header `<ratio>` synopsis <a id="ratio.syn">[[ratio.syn]]</a>
 ``` cpp
 namespace std {
@@ -6534,43 +7083,43 @@ namespace std {
   template <class R1, class R2> struct ratio_less_equal;
   template <class R1, class R2> struct ratio_greater;
   template <class R1, class R2> struct ratio_greater_equal;
   // [ratio.si], convenience SI typedefs
-  typedef ratio<1, 1000000000000000000000000> yocto;  // see below
-  typedef ratio<1,    1000000000000000000000> zepto;  // see below
-  typedef ratio<1,       1000000000000000000> atto;
-  typedef ratio<1,          1000000000000000> femto;
-  typedef ratio<1,             1000000000000> pico;
-  typedef ratio<1,                1000000000> nano;
-  typedef ratio<1,                   1000000> micro;
-  typedef ratio<1,                      1000> milli;
   typedef ratio<1,                               100> centi;
   typedef ratio<1,                                10> deci;
   typedef ratio<                               10, 1> deca;
   typedef ratio<                              100, 1> hecto;
-  typedef ratio<                     1000, 1> kilo;
-  typedef ratio<                  1000000, 1> mega;
-  typedef ratio<               1000000000, 1> giga;
-  typedef ratio<            1000000000000, 1> tera;
-  typedef ratio<         1000000000000000, 1> peta;
-  typedef ratio<      1000000000000000000, 1> exa;
-  typedef ratio<   1000000000000000000000, 1> zetta;  // see below
-  typedef ratio<1000000000000000000000000, 1> yotta;  // see below
 }
 ```
 ### Class template `ratio` <a id="ratio.ratio">[[ratio.ratio]]</a>
 ``` cpp
 namespace std {
   template <intmax_t N, intmax_t D = 1>
   class ratio {
   public:
-    typedef ratio<num, den> type;
     static constexpr intmax_t num;
     static constexpr intmax_t den;
   };
 }
 ```
 If the template argument `D` is zero or the absolute values of either of
@@ -6717,32 +7266,32 @@ namespace chrono {
 template <class Rep> struct treat_as_floating_point;
 template <class Rep> struct duration_values;
 // [time.duration.nonmember], duration arithmetic
 template <class Rep1, class Period1, class Rep2, class Period2>
- typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
   constexpr operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period1, class Rep2, class Period2>
- typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
   constexpr operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period, class Rep2>
-  duration<typename common_type<Rep1, Rep2>::type, Period>
   constexpr operator*(const duration<Rep1, Period>& d, const Rep2& s);
 template <class Rep1, class Rep2, class Period>
-  duration<typename common_type<Rep1, Rep2>::type, Period>
   constexpr operator*(const Rep1& s, const duration<Rep2, Period>& d);
 template <class Rep1, class Period, class Rep2>
-  duration<typename common_type<Rep1, Rep2>::type, Period>
   constexpr operator/(const duration<Rep1, Period>& d, const Rep2& s);
 template <class Rep1, class Period1, class Rep2, class Period2>
- typename common_type<Rep1, Rep2>::type
   constexpr operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period, class Rep2>
-  duration<typename common_type<Rep1, Rep2>::type, Period>
   constexpr operator%(const duration<Rep1, Period>& d, const Rep2& s);
 template <class Rep1, class Period1, class Rep2, class Period2>
- typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
   constexpr operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 // [time.duration.comparisons], duration comparisons
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr bool operator==(const duration<Rep1, Period1>& lhs,
@@ -6775,60 +7324,87 @@ typedef duration<signed integer type of at least 35 bits             > seconds;
 typedef duration<signed integer type of at least 29 bits, ratio<  60>> minutes;
 typedef duration<signed integer type of at least 23 bits, ratio<3600>> hours;
 // [time.point.nonmember], time_point arithmetic
 template <class Clock, class Duration1, class Rep2, class Period2>
-  time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
   operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period1, class Clock, class Duration2>
-  time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
   operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Rep2, class Period2>
-  time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
   operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Clock, class Duration1, class Duration2>
- typename common_type<Duration1, Duration2>::type
   operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 // [time.point.comparisons] time_point comparisons
 template <class Clock, class Duration1, class Duration2>
-   bool operator==(const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
-   bool operator!=(const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
-   bool operator< (const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
-   bool operator<=(const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
-   bool operator> (const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
-   bool operator>=(const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 // [time.point.cast], time_point_cast
 template <class ToDuration, class Clock, class Duration>
-  time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
 // [time.clock], clocks
 class system_clock;
 class steady_clock;
 class high_resolution_clock;
 }  // namespace chrono
 }  // namespace std
 ```
 ### Clock requirements <a id="time.clock.req">[[time.clock.req]]</a>
 A clock is a bundle consisting of a `duration`, a `time_point`, and a
-function `now()` to get the current time_point. The origin of the
 clock’s `time_point` is referred to as the clock’s *epoch*. A clock
 shall meet the requirements in Table  [[tab:time.clock]].
 In Table  [[tab:time.clock]] `C1` and `C2` denote clock types. `t1` and
 `t2` are values returned by `C1::now()` where the call returning `t1`
@@ -6853,12 +7429,12 @@ A type `TC` meets the `TrivialClock` requirements if:
   this means, in particular, that operations on these types will not
   throw exceptions.
 - lvalues of the types `TC::rep`, `TC::duration`, and `TC::time_point`
   are swappable ([[swappable.requirements]]),
 - the function `TC::now()` does not throw exceptions, and
-- the type `TC::time_point::clock` meets the TrivialClock requirements,
-  recursively.
 ### Time-related traits <a id="time.traits">[[time.traits]]</a>
 #### `treat_as_floating_point` <a id="time.traits.is_fp">[[time.traits.is_fp]]</a>
@@ -6926,11 +7502,11 @@ The value returned shall compare greater than `zero()`.
 #### Specializations of `common_type` <a id="time.traits.specializations">[[time.traits.specializations]]</a>
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
 struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>> {
-  typedef chrono::duration<typename common_type<Rep1, Rep2>::type, see below> type;
 };
 ```
 The `period` of the `duration` indicated by this specialization of
 `common_type` shall be the greatest common divisor of `Period1` and
@@ -6946,11 +7522,11 @@ this conversion with no truncation error, although floating-point
 durations may have round-off errors.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
 struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>> {
-  typedef chrono::time_point<Clock, typename common_type<Duration1, Duration2>::type> type;
 };
 ```
 The common type of two `time_point` types is a `time_point` with the
 same clock as the two types and the common type of their two
@@ -7021,10 +7597,15 @@ is ill-formed.
 *Remarks:* If `Period::num` is not positive, the program is ill-formed.
 *Requires:* Members of `duration` shall not throw exceptions other than
 those thrown by the indicated operations on their representations.
 ``` cpp
 duration<long, ratio<60>> d0;       // holds a count of minutes using a long
 duration<long long, milli> d1;      // holds a count of milliseconds using a long long
 duration<double, ratio<1, 30>>  d2; // holds a count with a tick period of $\frac{1}{30}$ of a second
                                     // (30 Hz) using a double
@@ -7056,11 +7637,12 @@ duration<int, milli> d(3.5);        // error
 template <class Rep2, class Period2>
   constexpr duration(const duration<Rep2, Period2>& d);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
-unless `treat_as_floating_point<rep>::value` is `true` or both
 `ratio_divide<Period2, period>::den` is `1` and
 `treat_as_floating_point<Rep2>::value` is `false`. This requirement
 prevents implicit truncation error when converting between
 integral-based `duration` types. Such a construction could easily lead
 to confusion about the value of the `duration`.
@@ -7194,53 +7776,53 @@ static constexpr duration max();
 *Returns:* `duration(duration_values<rep>::max())`.
 #### `duration` non-member arithmetic <a id="time.duration.nonmember">[[time.duration.nonmember]]</a>
 In the function descriptions that follow, `CD` represents the return
-type of the function. `CR(A,B)` represents `common_type<A, B>::type`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
   operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* CD(CD(lhs).count() + CD(rhs).count()).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
   operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* CD(CD(lhs).count() - CD(rhs).count()).
 ``` cpp
 template <class Rep1, class Period, class Rep2>
-  constexpr duration<typename common_type<Rep1, Rep2>::type, Period>
   operator*(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)`.
 *Returns:* CD(CD(d).count() \* s).
 ``` cpp
 template <class Rep1, class Rep2, class Period>
-  constexpr duration<typename common_type<Rep1, Rep2>::type, Period>
   operator*(const Rep1& s, const duration<Rep2, Period>& d);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep1` is implicitly convertible to `CR(Rep1, Rep2)`.
 *Returns:* `d * s`.
 ``` cpp
 template <class Rep1, class Period, class Rep2>
-  constexpr duration<typename common_type<Rep1, Rep2>::type, Period>
   operator/(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
@@ -7248,19 +7830,19 @@ is not an instantiation of `duration`.
 *Returns:* CD(CD(d).count() / s).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr typename common_type<Rep1, Rep2>::type
   operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `CD(lhs).count() / CD(rhs).count()`.
 ``` cpp
 template <class Rep1, class Period, class Rep2>
-  constexpr duration<typename common_type<Rep1, Rep2>::type, Period>
   operator%(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
@@ -7268,20 +7850,20 @@ is not an instantiation of `duration`.
 *Returns:* CD(CD(d).count() % s).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
   operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* CD(CD(lhs).count() % CD(rhs).count()).
 #### `duration` comparisons <a id="time.duration.comparisons">[[time.duration.comparisons]]</a>
 In the function descriptions that follow, `CT` represents
-`common_type<A, B>::type`, where `A` and `B` are the types of the two
 arguments to the function.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
@@ -7363,10 +7945,81 @@ conversions are done with `static_cast`. It avoids multiplications and
 divisions when it is known at compile time that one or more arguments
 is 1. Intermediate computations are carried out in the widest
 representation and only converted to the destination representation at
 the final step.
 ### Class template `time_point` <a id="time.point">[[time.point]]</a>
 ``` cpp
 template <class Clock, class Duration = typename Clock::duration>
 class time_point {
@@ -7378,17 +8031,17 @@ public:
 private:
   duration d_;  // exposition only
 public:
   // [time.point.cons], construct:
-  time_point();  // has value epoch
-  explicit time_point(const duration& d);  // same as time_point() + d
   template <class Duration2>
- time_point(const time_point<clock, Duration2>& t);
   // [time.point.observer], observer:
-  duration time_since_epoch() const;
   // [time.point.arithmetic], arithmetic:
   time_point& operator+=(const duration& d);
   time_point& operator-=(const duration& d);
@@ -7404,27 +8057,27 @@ If `Duration` is not an instance of `duration`, the program is
 ill-formed.
 #### `time_point` constructors <a id="time.point.cons">[[time.point.cons]]</a>
 ``` cpp
-time_point();
 ```
 *Effects:* Constructs an object of type `time_point`, initializing `d_`
 with `duration::zero()`. Such a `time_point` object represents the
 epoch.
 ``` cpp
-time_point(const duration& d);
 ```
 *Effects:* Constructs an object of type `time_point`, initializing `d_`
 with `d`. Such a `time_point` object represents the epoch `+ d`.
 ``` cpp
 template <class Duration2>
-  time_point(const time_point<clock, Duration2>& t);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
 unless `Duration2` is implicitly convertible to `duration`.
@@ -7432,11 +8085,11 @@ unless `Duration2` is implicitly convertible to `duration`.
 with `t.time_since_epoch()`.
 #### `time_point` observer <a id="time.point.observer">[[time.point.observer]]</a>
 ``` cpp
-duration time_since_epoch() const;
 ```
 *Returns:* `d_`.
 #### `time_point` arithmetic <a id="time.point.arithmetic">[[time.point.arithmetic]]</a>
@@ -7473,89 +8126,91 @@ static constexpr time_point max();
 #### `time_point` non-member arithmetic <a id="time.point.nonmember">[[time.point.nonmember]]</a>
 ``` cpp
 template <class Clock, class Duration1, class Rep2, class Period2>
-  time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
   operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
-*Returns:* `CT(lhs) += rhs`, where `CT` is the type of the return value.
 ``` cpp
 template <class Rep1, class Period1, class Clock, class Duration2>
-  time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
   operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `rhs + lhs`.
 ``` cpp
 template <class Clock, class Duration1, class Rep2, class Period2>
-  time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
   operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `lhs + (-rhs)`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
- typename common_type<Duration1, Duration2>::type
   operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `lhs.time_since_epoch() - rhs.time_since_epoch()`.
 #### `time_point` comparisons <a id="time.point.comparisons">[[time.point.comparisons]]</a>
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
-  bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `lhs.time_since_epoch() == rhs.time_since_epoch()`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
-  bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
-  bool operator<(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `lhs.time_since_epoch() < rhs.time_since_epoch()`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
-  bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
-  bool operator>(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
-  bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 #### `time_point_cast` <a id="time.point.cast">[[time.point.cast]]</a>
 ``` cpp
 template <class ToDuration, class Clock, class Duration>
-  time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
 ```
 *Remarks:* This function shall not participate in overload resolution
 unless `ToDuration` is an instantiation of `duration`.
@@ -7577,11 +8232,11 @@ class system_clock {
 public:
   typedef see below                           rep;
   typedef ratio<unspecified, unspecified>   period;
   typedef chrono::duration<rep, period>       duration;
   typedef chrono::time_point<system_clock>    time_point;
-  static const bool is_steady = unspecified;
   static time_point now() noexcept;
   // Map to C API
   static time_t      to_time_t  (const time_point& t) noexcept;
@@ -7627,11 +8282,11 @@ class steady_clock {
 public:
   typedef unspecified                               rep;
   typedef ratio<unspecified, unspecified>          period;
   typedef chrono::duration<rep, period>              duration;
   typedef chrono::time_point<unspecified, duration>  time_point;
-  static const bool is_steady = true;
   static time_point now() noexcept;
 };
 ```
@@ -7646,11 +8301,11 @@ class high_resolution_clock {
 public:
   typedef unspecified                               rep;
   typedef ratio<unspecified, unspecified>          period;
   typedef chrono::duration<rep, period>              duration;
   typedef chrono::time_point<unspecified, duration> time_point;
-  static const bool is_steady = unspecified;
   static time_point now() noexcept;
 };
 ```
@@ -7757,11 +8412,11 @@ namespace std {
     pointer allocate(size_type n, const_void_pointer hint);
     void deallocate(pointer p, size_type n);
     size_type max_size() const;
     template <class T, class... Args>
-      void construct(T* p, Args&& args);
     template <class T1, class T2, class... Args1, class... Args2>
       void construct(pair<T1, T2>* p, piecewise_construct_t,
                      tuple<Args1...> x, tuple<Args2...> y);
     template <class T1, class T2>
       void construct(pair<T1, T2>* p);
@@ -7828,11 +8483,11 @@ any `A` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise,
 ``` cpp
 scoped_allocator_adaptor();
 ```
-*Effects:* value-initializes the OuterAlloc base class and the `inner`
 allocator object.
 ``` cpp
 template <class OuterA2>
   scoped_allocator_adaptor(OuterA2&& outerAlloc,
@@ -7985,16 +8640,16 @@ following rules:
   `x`.
 - Otherwise, if `uses_allocator<T1, inner_allocator_type>::value` is
   `true` and
   `is_constructible<T1, allocator_arg_t, inner_allocator_type, Args1...>::value`
   is `true`, then `xprime` is
-  `tuple_cat(tuple<allocator_arg_t, inner_allocator_type&>( allocator_arg, inner_allocator_type()), x)`.
 - Otherwise, if `uses_allocator<T1, inner_allocator_type>::value` is
   `true` and
   `is_constructible<T1, Args1..., inner_allocator_type>::value` is
   `true`, then `xprime` is
-  `tuple_cat(x, tuple<inner_allocator_type&>(inner_allocator_type()))`.
 - Otherwise, the program is ill-formed.
 and constructs a `tuple` object `yprime` from `y` by the following
 rules:
@@ -8003,52 +8658,52 @@ rules:
   `y`.
 - Otherwise, if `uses_allocator<T2, inner_allocator_type>::value` is
   `true` and
   `is_constructible<T2, allocator_arg_t, inner_allocator_type, Args2...>::value`
   is `true`, then `yprime` is
-  `tuple_cat(tuple<allocator_arg_t, inner_allocator_type&>( allocator_arg, inner_allocator_type()), y)`.
 - Otherwise, if `uses_allocator<T2, inner_allocator_type>::value` is
   `true` and
   `is_constructible<T2, Args2..., inner_allocator_type>::value` is
   `true`, then `yprime` is
-  `tuple_cat(y, tuple<inner_allocator_type&>(inner_allocator_type()))`.
 - Otherwise, the program is ill-formed.
 then calls
 *`OUTERMOST_ALLOC_TRAITS`*`(*this)::construct(`*`OUTERMOST`*`(*this), p,`
-`piecewise_construct, xprime, yprime)`.
 ``` cpp
 template <class T1, class T2>
   void construct(pair<T1, T2>* p);
 ```
-*Effects:* equivalent to
 `this->construct(p, piecewise_construct, tuple<>(), tuple<>())`.
 ``` cpp
 template <class T1, class T2, class U, class V>
   void construct(pair<T1, T2>* p, U&& x, V&& y);
 ```
-*Effects:* equivalent to
 `this->construct(p, piecewise_construct, forward_as_tuple(std::forward<U>(x)), forward_as_tuple(std::forward<V>(y)))`.
 ``` cpp
 template <class T1, class T2, class U, class V>
   void construct(pair<T1, T2>* p, const pair<U, V>& x);
 ```
-*Effects:* equivalent to
 `this->construct(p, piecewise_construct, forward_as_tuple(x.first), forward_as_tuple(x.second))`.
 ``` cpp
 template <class T1, class T2, class U, class V>
   void construct(pair<T1, T2>* p, pair<U, V>&& x);
 ```
-*Effects:* equivalent to
 `this->construct(p, piecewise_construct, forward_as_tuple(std::forward<U>(x.first)), forward_as_tuple(std::forward<V>(x.second)))`.
 ``` cpp
 template <class T>
   void destroy(T* p);
@@ -8110,12 +8765,12 @@ namespace std {
     bool operator!=(const type_index& rhs) const noexcept;
     bool operator< (const type_index& rhs) const noexcept;
     bool operator<= (const type_index& rhs) const noexcept;
     bool operator> (const type_index& rhs) const noexcept;
     bool operator>= (const type_index& rhs) const noexcept;
-    size_t hash_code() const;
-    const char* name() const;
   private:
     const type_info* target;    // exposition only
     // Note that the use of a pointer here, rather than a reference,
     // means that the default copy/move constructor and assignment
     // operators will be provided and work as expected.
@@ -8171,29 +8826,29 @@ bool operator>=(const type_index& rhs) const noexcept;
 ```
 *Returns:* `!target->before(*rhs.target)`
 ``` cpp
-size_t hash_code() const;
 ```
 *Returns:* `target->hash_code()`
 ``` cpp
-const char* name() const;
 ```
 *Returns:* `target->name()`
 ### Hash support <a id="type.index.hash">[[type.index.hash]]</a>
 ``` cpp
 template <> struct hash<type_index>;
 ```
-*Requires:* the template specialization shall meet the requirements of
-class template `hash` ([[unord.hash]]). For an object `index` of type
 `type_index`, `hash<type_index>()(index)` shall evaluate to the same
 result as `index.hash_code()`.
 <!-- Link reference definitions -->
 [alg.sorting]: algorithms.md#alg.sorting
@@ -8224,18 +8879,18 @@ result as `index.hash_code()`.
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.stc.dynamic.safety]: basic.md#basic.stc.dynamic.safety
 [basic.type.qualifier]: basic.md#basic.type.qualifier
 [basic.types]: basic.md#basic.types
-[bind]: #bind
 [bitset.cons]: #bitset.cons
 [bitset.hash]: #bitset.hash
 [bitset.members]: #bitset.members
 [bitset.operators]: #bitset.operators
 [bitwise.operations]: #bitwise.operations
 [c.malloc]: #c.malloc
 [c.strings]: strings.md#c.strings
 [class.abstract]: class.md#class.abstract
 [class.derived]: class.md#class.derived
 [class.dtor]: special.md#class.dtor
 [class.virtual]: class.md#class.virtual
 [comparisons]: #comparisons
@@ -8271,10 +8926,11 @@ result as `index.hash_code()`.
 [forward]: #forward
 [forward.iterators]: iterators.md#forward.iterators
 [func.bind]: #func.bind
 [func.bind.bind]: #func.bind.bind
 [func.bind.isbind]: #func.bind.isbind
 [func.bind.place]: #func.bind.place
 [func.def]: #func.def
 [func.memfn]: #func.memfn
 [func.require]: #func.require
 [func.wrap]: #func.wrap
@@ -8290,10 +8946,14 @@ result as `index.hash_code()`.
 [func.wrap.func.targ]: #func.wrap.func.targ
 [function.objects]: #function.objects
 [hash.requirements]: library.md#hash.requirements
 [input.iterators]: iterators.md#input.iterators
 [intro.multithread]: intro.md#intro.multithread
 [invalid.argument]: diagnostics.md#invalid.argument
 [iostate.flags]: input.md#iostate.flags
 [istream.formatted]: input.md#istream.formatted
 [lessthancomparable]: #lessthancomparable
 [logical.operations]: #logical.operations
@@ -8379,10 +9039,11 @@ result as `index.hash_code()`.
 [time.duration]: #time.duration
 [time.duration.arithmetic]: #time.duration.arithmetic
 [time.duration.cast]: #time.duration.cast
 [time.duration.comparisons]: #time.duration.comparisons
 [time.duration.cons]: #time.duration.cons
 [time.duration.nonmember]: #time.duration.nonmember
 [time.duration.observer]: #time.duration.observer
 [time.duration.special]: #time.duration.special
 [time.general]: #time.general
 [time.point]: #time.point
@@ -8417,10 +9078,11 @@ result as `index.hash_code()`.
 [type.index.synopsis]: #type.index.synopsis
 [uninitialized.copy]: #uninitialized.copy
 [uninitialized.fill]: #uninitialized.fill
 [uninitialized.fill.n]: #uninitialized.fill.n
 [unique.ptr]: #unique.ptr
 [unique.ptr.dltr]: #unique.ptr.dltr
 [unique.ptr.dltr.dflt]: #unique.ptr.dltr.dflt
 [unique.ptr.dltr.dflt1]: #unique.ptr.dltr.dflt1
 [unique.ptr.dltr.general]: #unique.ptr.dltr.general
 [unique.ptr.runtime]: #unique.ptr.runtime
@@ -8463,10 +9125,11 @@ result as `index.hash_code()`.
 [util.smartptr.weak.spec]: #util.smartptr.weak.spec
 [util.smartptr.weakptr]: #util.smartptr.weakptr
 [utilities]: #utilities
 [utilities.general]: #utilities.general
 [utility]: #utility
 [utility.swap]: #utility.swap
 [^1]: `pointer_safety::preferred` might be returned to indicate that a
     leak detector is running so that the program can avoid spurious leak
     reports.

 | Subclause             |                                  | Header               |
 | --------------------- | -------------------------------- | -------------------- |
 | [[utility]]           | Utility components               | `<utility>`          |
 | [[pairs]]             | Pairs                            | `<utility>`          |
 | [[tuple]]             | Tuples                           | `<tuple>`            |
+| [[intseq]]            | Compile-time integer sequences   | `<utility>`          |
 | [[template.bitset]]   | Fixed-size sequences of bits     | `<bitset>`           |
 |                       |                                  | `<memory>`           |
 | [[memory]]            | Memory                           | `<cstdlib>`          |
 |                       |                                  | `<cstring>`          |
 | [[smartptr]]          | Smart pointers                   | `<memory>`           |
   // [utility.swap], swap:
   template<class T> void swap(T& a, T& b) noexcept(see below);
   template <class T, size_t N> void swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b)));
+  // [utility.exchange], exchange:
+  template <class T, class U=T> T exchange(T& obj, U&& new_val);
   // [forward], forward/move:
+  template <class T>
+    constexpr T&& forward(remove_reference_t<T>& t) noexcept;
+  template <class T>
+    constexpr T&& forward(remove_reference_t<T>&& t) noexcept;
+  template <class T>
+    constexpr remove_reference_t<T>&& move(T&&) noexcept;
+  template <class T>
+    constexpr conditional_t<
     !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
+    const T&, T&&> move_if_noexcept(T& x) noexcept;
   // [declval], declval:
   template <class T>
+ add_rvalue_reference_t<T> declval() noexcept;  // as unevaluated operand
   // [pairs], pairs:
   template <class T1, class T2> struct pair;
   // [pairs.spec], pair specialized algorithms:
   template <class T1, class T2>
+ constexpr bool operator==(const pair<T1,T2>&, const pair<T1,T2>&);
   template <class T1, class T2>
+ constexpr bool operator< (const pair<T1,T2>&, const pair<T1,T2>&);
   template <class T1, class T2>
+ constexpr bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&);
   template <class T1, class T2>
+ constexpr bool operator> (const pair<T1,T2>&, const pair<T1,T2>&);
   template <class T1, class T2>
+ constexpr bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&);
   template <class T1, class T2>
+ constexpr bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&);
   template <class T1, class T2>
     void swap(pair<T1,T2>& x, pair<T1,T2>& y) noexcept(noexcept(x.swap(y)));
   template <class T1, class T2>
+ constexpr see below make_pair(T1&&, T2&&);
   // [pair.astuple], tuple-like access to pair:
   template <class T> class tuple_size;
   template <size_t I, class T> class tuple_element;
+  template <class T1, class T2> struct tuple_size<pair<T1, T2> >;
+  template <class T1, class T2> struct tuple_element<0, pair<T1, T2> >;
+  template <class T1, class T2> struct tuple_element<1, pair<T1, T2> >;
   template<size_t I, class T1, class T2>
+ constexpr tuple_element_t<I, pair<T1, T2>>&
+      get(pair<T1, T2>&) noexcept;
   template<size_t I, class T1, class T2>
+ constexpr tuple_element_t<I, pair<T1, T2>>&&
+      get(pair<T1, T2>&&) noexcept;
   template<size_t I, class T1, class T2>
+ constexpr const tuple_element_t<I, pair<T1, T2>>&
+      get(const pair<T1, T2>&) noexcept;
+  template <class T, class U>
+    constexpr T& get(pair<T, U>& p) noexcept;
+  template <class T, class U>
+    constexpr const T& get(const pair<T, U>& p) noexcept;
+  template <class T, class U>
+    constexpr T&& get(pair<T, U>&& p) noexcept;
+  template <class T, class U>
+    constexpr T& get(pair<U, T>& p) noexcept;
+  template <class T, class U>
+    constexpr const T& get(const pair<U, T>& p) noexcept;
+  template <class T, class U>
+    constexpr T&& get(pair<U, T>&& p) noexcept;
   // [pair.piecewise], pair piecewise construction
   struct piecewise_construct_t { };
+  constexpr piecewise_construct_t piecewise_construct{};
   template <class... Types> class tuple;  // defined in <tuple>
+  // [intseq], Compile-time integer sequences
+  template<class T, T...> struct integer_sequence;
+  template<size_t... I>
+    using index_sequence = integer_sequence<size_t, I...>;
+  template<class T, T N>
+    using make_integer_sequence = integer_sequence<T, see below>;
+  template<size_t N>
+    using make_index_sequence = make_integer_sequence<size_t, N>;
+  template<class... T>
+    using index_sequence_for = make_index_sequence<sizeof...(T)>;
 }
 ```
 ### Operators <a id="operators">[[operators]]</a>
 *Requires:* `a[i]` shall be swappable with ([[swappable.requirements]])
 `b[i]` for all `i` in the range \[`0`, `N`).
 *Effects:* `swap_ranges(a, a + N, b)`
+### exchange <a id="utility.exchange">[[utility.exchange]]</a>
+``` cpp
+template <class T, class U=T> T exchange(T& obj, U&& new_val);
+```
+*Effects:* Equivalent to:
+``` cpp
+T old_val = std::move(obj);
+obj = std::forward<U>(new_val);
+return old_val;
+```
 ### forward/move helpers <a id="forward">[[forward]]</a>
 The library provides templated helper functions to simplify applying
 move semantics to an lvalue and to simplify the implementation of
 forwarding functions.
 ``` cpp
+template <class T> constexpr T&& forward(remove_reference_t<T>& t) noexcept;
+template <class T> constexpr T&& forward(remove_reference_t<T>&& t) noexcept;
 ```
 *Returns:* `static_cast<T&&>(t)`.
+If the second form is instantiated with an lvalue reference type, the
 program is ill-formed.
 ``` cpp
 template <class T, class A1, class A2>
 shared_ptr<T> factory(A1&& a1, A2&& a2) {
 `factory`, `A1` is deduced as `int&`, so `i` is forwarded to `A`’s
 constructor as an lvalue. In both cases, `A2` is deduced as `double`, so
 1.414 is forwarded to `A`’s constructor as an rvalue.
 ``` cpp
+template <class T> constexpr remove_reference_t<T>&& move(T&& t) noexcept;
 ```
+*Returns:* `static_cast<remove_reference_t<T>&&>(t)`.
 ``` cpp
 template <class T, class A1>
 shared_ptr<T> factory(A1&& a1) {
   return shared_ptr<T>(new T(std::forward<A1>(a1)));
 `factory`, because of the call `std::move(a)`, `A1` is deduced as `A`,
 so `a` is forwarded as an rvalue. This binds to the constructor
 `A(A&&)`, which moves the value from `a`.
 ``` cpp
+template <class T> constexpr conditional_t<
   !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
+  const T&, T&&> move_if_noexcept(T& x) noexcept;
 ```
 *Returns:* `std::move(x)`
 ### Function template `declval` <a id="declval">[[declval]]</a>
 definition of expressions which occur as unevaluated operands (Clause
 [[expr]]).
 ``` cpp
 template <class T>
+ add_rvalue_reference_t<T> declval() noexcept;  // as unevaluated operand
 ```
 *Remarks:* If this function is odr-used ([[basic.def.odr]]), the
 program is ill-formed.
     T1 first;
     T2 second;
     pair(const pair&) = default;
     pair(pair&&) = default;
     constexpr pair();
+ constexpr pair(const T1& x, const T2& y);
+    template<class U, class V> constexpr pair(U&& x, V&& y);
+    template<class U, class V> constexpr pair(const pair<U, V>& p);
+    template<class U, class V> constexpr pair(pair<U, V>&& p);
     template <class... Args1, class... Args2>
       pair(piecewise_construct_t,
            tuple<Args1...> first_args, tuple<Args2...> second_args);
     pair& operator=(const pair& p);
     void swap(pair& p) noexcept(see below);
   };
 }
 ```
+Constructors and member functions of `pair` shall not throw exceptions
 unless one of the element-wise operations specified to be called for
 that operation throws an exception.
+The defaulted move and copy constructor, respectively, of pair 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.
 ``` cpp
 constexpr pair();
 ```
 *Requires:* `is_default_constructible<first_type>::value` is `true` and
 `ible<second_type>::value` is `true`.
 *Effects:* Value-initializes `first` and `second`.
 ``` cpp
+constexpr pair(const T1& x, const T2& y);
 ```
 *Requires:* `is_copy_constructible<first_type>::value` is `true` and
 `is_copy_constructible<second_type>::value` is `true`.
 *Effects:* The constructor initializes `first` with `x` and `second`
 with `y`.
 ``` cpp
+template<class U, class V> constexpr pair(U&& x, V&& y);
 ```
 *Requires:* `is_constructible<first_type, U&&>::value` is `true` and
 `is_constructible<second_type, V&&>::value` is `true`.
 *Remarks:* If `U` is not implicitly convertible to `first_type` or `V`
 is not implicitly convertible to `second_type` this constructor shall
 not participate in overload resolution.
 ``` cpp
+template<class U, class V> constexpr pair(const pair<U, V>& p);
 ```
 *Requires:* `is_constructible<first_type, const U&>::value` is `true`
 and `is_constructible<second_type, const V&>::value` is `true`.
 This constructor shall not participate in overload resolution unless
 `const U&` is implicitly convertible to `first_type` and `const V&` is
 implicitly convertible to `second_type`.
 ``` cpp
+template<class U, class V> constexpr pair(pair<U, V>&& p);
 ```
 *Requires:* `is_constructible<first_type, U&&>::value` is `true` and
 `is_constructible<second_type, V&&>::value` is `true`.
 template<class... Args1, class... Args2>
   pair(piecewise_construct_t,
        tuple<Args1...> first_args, tuple<Args2...> second_args);
 ```
+*Requires:* `is_constructible<first_type, Args1&&...>::value` is `true`
+and `is_constructible<second_type, Args2&&...>::value` is `true`.
 *Effects:* The constructor initializes `first` with arguments of types
 `Args1...` obtained by forwarding the elements of `first_args` and
 initializes `second` with arguments of types `Args2...` obtained by
 forwarding the elements of `second_args`. (Here, forwarding an element
 ``` cpp
 template<class U, class V> pair& operator=(const pair<U, V>& p);
 ```
+*Requires:* `is_assignable<first_type&, const U&>::value` is `true` and
+`is_assignable<second_type&, const V&>::value` is `true`.
 *Effects:* Assigns `p.first` to `first` and `p.second` to `second`.
 *Returns:* `*this`.
 ### Specialized algorithms <a id="pairs.spec">[[pairs.spec]]</a>
 ``` cpp
 template <class T1, class T2>
+ constexpr bool operator==(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `x.first == y.first && x.second == y.second`.
 ``` cpp
 template <class T1, class T2>
+ constexpr bool operator<(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:*
 `x.first < y.first || (!(y.first < x.first) && x.second < y.second)`.
 ``` cpp
 template <class T1, class T2>
+ constexpr bool operator!=(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `!(x == y)`
 ``` cpp
 template <class T1, class T2>
+ constexpr bool operator>(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `y < x`
 ``` cpp
 template <class T1, class T2>
+ constexpr bool operator>=(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `!(x < y)`
 ``` cpp
 template <class T1, class T2>
+ constexpr bool operator<=(const pair<T1, T2>& x, const pair<T1, T2>& y);
 ```
 *Returns:* `!(y < x)`
 ``` cpp
 *Effects:* `x.swap(y)`
 ``` cpp
 template <class T1, class T2>
+ constexpr pair<V1, V2> make_pair(T1&& x, T2&& y);
 ```
 *Returns:* `pair<V1, V2>(std::forward<T1>(x), std::forward<T2>(y))`;
+where `V1` and `V2` are determined as follows: Let `Ui` be `decay_t<Ti>`
+for each `Ti`. Then each `Vi` is `X&` if `Ui` equals
 `reference_wrapper<X>`, otherwise `Vi` is `Ui`.
 In place of:
 ``` cpp
 ```
 ### Tuple-like access to pair <a id="pair.astuple">[[pair.astuple]]</a>
 ``` cpp
+template <class T1, class T2>
+struct tuple_size<pair<T1, T2>>
+  : integral_constant<size_t, 2> { };
 ```
 ``` cpp
 tuple_element<0, pair<T1, T2> >::type
 ```
 *Value:* the type `T1`.
 *Value:* the type T2.
 ``` cpp
 template<size_t I, class T1, class T2>
+ constexpr tuple_element_t<I, pair<T1, T2>>&
+    get(pair<T1, T2>& p) noexcept;
 template<size_t I, class T1, class T2>
+ constexpr const tuple_element_t<I, pair<T1, T2>>&
+    get(const pair<T1, T2>& p) noexcept;
 ```
 *Returns:* If `I == 0` returns `p.first`; if `I == 1` returns
 `p.second`; otherwise the program is ill-formed.
 ``` cpp
 template<size_t I, class T1, class T2>
+ constexpr tuple_element_t<I, pair<T1, T2>>&&
+    get(pair<T1, T2>&& p) noexcept;
 ```
 *Returns:* If `I == 0` returns `std::forward<T1&&>(p.first)`; if
 `I == 1` returns `std::forward<T2&&>(p.second)`; otherwise the program
 is ill-formed.
+``` cpp
+template <class T, class U>
+  constexpr T& get(pair<T, U>& p) noexcept;
+template <class T, class U>
+  constexpr const T& get(const pair<T, U>& p) noexcept;
+```
+*Requires:* `T` and `U` are distinct types. Otherwise, the program is
+ill-formed.
+*Returns:* `get<0>(p);`
+``` cpp
+template <class T, class U>
+  constexpr T&& get(pair<T, U>&& p) noexcept;
+```
+*Requires:* `T` and `U` are distinct types. Otherwise, the program is
+ill-formed.
+*Returns:* `get<0>(std::move(p));`
+``` cpp
+template <class T, class U>
+  constexpr T& get(pair<U, T>& p) noexcept;
+template <class T, class U>
+  constexpr const T& get(const pair<U, T>& p) noexcept;
+```
+*Requires:* `T` and `U` are distinct types. Otherwise, the program is
+ill-formed.
+*Returns:* `get<1>(p);`
+``` cpp
+template <class T, class U>
+  constexpr T&& get(pair<U, T>&& p) noexcept;
+```
+*Requires:* `T` and `U` are distinct types. Otherwise, the program is
+ill-formed.
+*Returns:* `get<1>(std::move(p));`
 ### Piecewise construction <a id="pair.piecewise">[[pair.piecewise]]</a>
 ``` cpp
 struct piecewise_construct_t { };
+constexpr piecewise_construct_t piecewise_construct{};
 ```
 The `struct` `piecewise_construct_t` is an empty structure type used as
 a unique type to disambiguate constructor and function overloading.
 Specifically, `pair` has a constructor with `piecewise_construct_t` as
   // [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 <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>
+ constexpr bool operator!=(const tuple<TTypes...>&, const tuple<UTypes...>&);
   template<class... TTypes, class... UTypes>
+ constexpr bool operator>(const tuple<TTypes...>&, const tuple<UTypes...>&);
   template<class... TTypes, class... UTypes>
+ constexpr bool operator<=(const tuple<TTypes...>&, const tuple<UTypes...>&);
   template<class... TTypes, class... UTypes>
+ constexpr bool operator>=(const tuple<TTypes...>&, const tuple<UTypes...>&);
   // [tuple.traits], allocator-related traits
   template <class... Types, class Alloc>
     struct uses_allocator<tuple<Types...>, Alloc>;
   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& operator=(const tuple<UTypes...>&);
     template <class... UTypes>
       tuple& operator=(tuple<UTypes...>&&);
     template <class U1, class U2>
+      tuple& operator=(const pair<U1, U2>&);    // only if sizeof...(Types) == 2
     template <class U1, class U2>
+      tuple& operator=(pair<U1, U2>&&);         // only if sizeof...(Types) == 2
     // [tuple.swap], tuple swap
     void swap(tuple&) noexcept(see below);
   };
 }
 #### 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.
 *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:* 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.
 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.
 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`
 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
 ``` 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
 `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)...)`.
 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
 *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
 // 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
 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)> { };
 ```
 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>;
 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));`
 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.
 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>
+ constexpr bool operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 ```
+*Requires:* For all `i`, where `0 <= i` and `i < sizeof...(TTypes)`,
 `get<i>(t) == get<i>(u)` is a valid expression returning a type that is
 convertible to `bool`. `sizeof...(TTypes)` `==` `sizeof...(UTypes)`.
+*Returns:* `true` if `get<i>(t) == get<i>(u)` for all `i`, otherwise
+`false`. For any two zero-length tuples `e` and `f`, `e == f` returns
+`true`.
 *Effects:* The elementary comparisons are performed in order from the
 zeroth index upwards. No comparisons or element accesses are performed
 after the first equality comparison that evaluates to `false`.
 ``` cpp
 template<class... TTypes, class... UTypes>
+ constexpr bool operator<(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 ```
+*Requires:* For all `i`, where `0 <= i` and `i < sizeof...(TTypes)`,
 `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
 element of `r`. For any two zero-length tuples `e` and `f`, `e < f`
 returns `false`.
 ``` cpp
 template<class... TTypes, class... UTypes>
+ constexpr bool operator!=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 ```
 *Returns:* `!(t == u)`.
 ``` cpp
 template<class... TTypes, class... UTypes>
+ constexpr bool operator>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 ```
 *Returns:* `u < t`.
 ``` cpp
 template<class... TTypes, class... UTypes>
+ constexpr bool operator<=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 ```
 *Returns:* `!(u < t)`
 ``` cpp
 template<class... TTypes, class... UTypes>
+ constexpr bool operator>=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 ```
 *Returns:* `!(t < u)`
 The above definitions for comparison operators do not require `tₜₐᵢₗ`
 noexcept(x.swap(y))
 ```
 *Effects:* `x.swap(y)`
+## Compile-time integer sequences <a id="intseq">[[intseq]]</a>
+### In general <a id="intseq.general">[[intseq.general]]</a>
+The library provides a class template that can represent an integer
+sequence. When used as an argument to a function template the parameter
+pack defining the sequence can be deduced and used in a pack expansion.
+``` cpp
+template<class F, class Tuple, std::size_t... I>
+  decltype(auto) apply_impl(F&& f, Tuple&& t, index_sequence<I...>) {
+    return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
+  }
+template<class F, class Tuple>
+  decltype(auto) apply(F&& f, Tuple&& t) {
+    using Indices = make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>;
+    return apply_impl(std::forward<F>(f), std::forward<Tuple>(t), Indices());
+  }
+```
+The `index_sequence` alias template is provided for the common case of
+an integer sequence of type `size_t`.
+### Class template `integer_sequence` <a id="intseq.intseq">[[intseq.intseq]]</a>
+``` cpp
+namespace std {
+  template<class T, T... I>
+  struct integer_sequence {
+    typedef T value_type;
+    static constexpr size_t size() noexcept { return sizeof...(I); }
+  };
+}
+```
+`T` shall be an integer type.
+### Alias template `make_integer_sequence` <a id="intseq.make">[[intseq.make]]</a>
+``` cpp
+template<class T, T N>
+  using make_integer_sequence = integer_sequence<T, see below>;
+```
+If `N` is negative the program is ill-formed. The alias template
+`make_integer_sequence` denotes a specialization of `integer_sequence`
+with `N` template non-type arguments. The type
+`make_integer_sequence<T, N>` denotes the type
+`integer_sequence<T, 0, 1, ..., N-1>`. `make_integer_sequence<int, 0>`
+denotes the type `integer_sequence<int>`
 ## Class template `bitset` <a id="template.bitset">[[template.bitset]]</a>
 \synopsis{Header \texttt{\<bitset\>} synopsis}
 ``` cpp
         class traits = char_traits<charT>,
         class Allocator = allocator<charT> >
       basic_string<charT, traits, Allocator>
       to_string(charT zero = charT('0'), charT one = charT('1')) const;
     size_t count() const noexcept;
+    constexpr size_t size() const noexcept;
     bool operator==(const bitset<N>& rhs) const noexcept;
     bool operator!=(const bitset<N>& rhs) const noexcept;
     bool test(size_t pos) const;
     bool all() const noexcept;
     bool any() const noexcept;
 Otherwise, the function constructs an object of class `bitset<N>`,
 initializing the first `M` bit positions to values determined from the
 corresponding characters in the string `str`. `M` is the smaller of `N`
 and `rlen`.
+An element of the constructed object has value zero if the corresponding
+character in `str`, beginning at position `pos`, is `zero`. Otherwise,
+the element has the value one. Character position `pos + M - 1`
 corresponds to bit position zero. Subsequent decreasing character
 positions correspond to increasing bit positions.
 If `M < N`, remaining bit positions are initialized to zero.
 ```
 *Returns:* A count of the number of bits set in `*this`.
 ``` cpp
+constexpr size_t size() const noexcept;
 ```
 *Returns:* `N`.
 ``` cpp
 ```
 *Returns:* `bitset<N>(*this) >>= pos`.
 ``` cpp
+constexpr bool operator[](size_t pos) const;
 ```
 *Requires:* `pos` shall be valid.
 *Returns:* `true` if the bit at position `pos` in `*this` has the value
 ``` cpp
 template <size_t N> struct hash<bitset<N> >;
 ```
+The template specialization shall meet the requirements of class
+template `hash` ([[unord.hash]]).
 ### `bitset` operators <a id="bitset.operators">[[bitset.operators]]</a>
 ``` cpp
 bitset<N> operator&(const bitset<N>& lhs, const bitset<N>& rhs) noexcept;
 ### In general <a id="memory.general">[[memory.general]]</a>
 This subclause describes the contents of the header `<memory>` (
 [[memory.syn]]) and some of the contents of the C headers `<cstdlib>`
+and `<cstring>` ([[c.malloc]]).
 ### Header `<memory>` synopsis <a id="memory.syn">[[memory.syn]]</a>
 The header `<memory>` defines several types and function templates that
 describe properties of pointers and pointer-like types, manage memory
 for containers and other template types, and construct multiple objects
 in uninitialized memory buffers ([[pointer.traits]]–
 [[specialized.algorithms]]). The header also defines the templates
+`unique_ptr`, `shared_ptr`, `weak_ptr`, and various function templates
 that operate on objects of these types ([[smartptr]]).
 ``` cpp
 namespace std {
   // [pointer.traits], pointer traits
   void* align(std::size_t alignment, std::size_t size,
     void*& ptr, std::size_t& space);
   // [allocator.tag], allocator argument tag
   struct allocator_arg_t { };
+  constexpr allocator_arg_t allocator_arg{};
   // [allocator.uses], uses_allocator
   template <class T, class Alloc> struct uses_allocator;
   // [allocator.traits], allocator traits
   template <class T> struct default_delete;
   template <class T> struct default_delete<T[]>;
   template <class T, class D = default_delete<T>> class unique_ptr;
   template <class T, class D> class unique_ptr<T[], D>;
+  template <class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
+  template <class T> unique_ptr<T> make_unique(size_t n);
+  template <class T, class... Args> unspecified make_unique(Args&&...) = delete;
+  template <class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
   template <class T1, class D1, class T2, class D2>
     bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template <class T1, class D1, class T2, class D2>
     bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template <class T1, class D1, class T2, class D2>
   class bad_weak_ptr;
   // [util.smartptr.shared], class template shared_ptr:
   template<class T> class shared_ptr;
+  // [util.smartptr.shared.create], shared_ptr creation
+  template<class T, class... Args> shared_ptr<T> make_shared(Args&&... args);
+  template<class T, class A, class... Args>
+    shared_ptr<T> allocate_shared(const A& a, Args&&... args);
   // [util.smartptr.shared.cmp], shared_ptr comparisons:
   template<class T, class U>
     bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
   template<class T, class U>
     bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
 ``` cpp
 static pointer pointer_traits::pointer_to(see below r);
 static pointer pointer_traits<T*>::pointer_to(see below r) noexcept;
 ```
+If `element_type` is (possibly cv-qualified) `void`, the type of `r` is
 unspecified; otherwise, it is `element_type&`.
+*Returns:* The first member function returns a pointer to `r` obtained
+by calling `Ptr::pointer_to(r)` through which indirection is valid; an
+instantiation of this function is ill-formed if `Ptr` does not have a
+matching `pointer_to` static member function. The second member function
+returns `std::addressof(r)`.
 ### Pointer safety <a id="util.dynamic.safety">[[util.dynamic.safety]]</a>
 A complete object is *declared reachable* while the number of calls to
 `declare_reachable` with an argument referencing the object exceeds the
 call. In a garbage-collecting implementation, the fact that a region in
 an object is registered with `declare_no_pointers()` should not prevent
 the object from being collected.
 *Effects:* The `n` bytes starting at `p` no longer contain traceable
+pointer locations, independent of their type. Hence indirection through
+a pointer located there is undefined if the object it points to was
+created by global `operator new` and not previously declared reachable.
+This may be used to inform a garbage collector or leak detector that
+this region of memory need not be traced.
 *Throws:* Nothing.
 Under some conditions implementations may need to allocate memory.
 However, the request can be ignored if memory allocation fails.
 ### Allocator argument tag <a id="allocator.tag">[[allocator.tag]]</a>
 ``` cpp
 namespace std {
   struct allocator_arg_t { };
+  constexpr allocator_arg_t allocator_arg{};
 }
 ```
 The `allocator_arg_t` struct is an empty structure type used as a unique
 type to disambiguate constructor and function overloading. Specifically,
       static void construct(Alloc& a, T* p, Args&&... args);
     template <class T>
       static void destroy(Alloc& a, T* p);
+    static size_type max_size(const Alloc& a) noexcept;
     static Alloc select_on_container_copy_construction(const Alloc& rhs);
   };
 }
 ```
 ``` cpp
 typedef see below size_type;
 ```
 *Type:* `Alloc::size_type` if such a type exists; otherwise,
+`make_unsigned_t<difference_type>`.
 ``` cpp
 typedef see below propagate_on_container_copy_assignment;
 ```
 *Effects:* calls `a.destroy(p)` if that call is well-formed; otherwise,
 invokes `p->~T()`.
 ``` cpp
+static size_type max_size(const Alloc& a) noexcept;
 ```
 *Returns:* `a.max_size()` if that expression is well-formed; otherwise,
 `numeric_limits<size_type>::max()`.
     typedef const T*  const_pointer;
     typedef T&        reference;
     typedef const T&  const_reference;
     typedef T         value_type;
     template <class U> struct rebind { typedef allocator<U> other; };
+    typedef true_type propagate_on_container_move_assignment;
     allocator() noexcept;
     allocator(const allocator&) noexcept;
     template <class U> allocator(const allocator<U>&) noexcept;
    ~allocator();
 shall equal the value passed as the first argument to the invocation of
 allocate which returned `p`.
 *Effects:* Deallocates the storage referenced by `p` .
+*Remarks:* Uses
+`::operator delete(void*, std::size_t)` ([[new.delete]]), but it is
 unspecified when this function is called.
 ``` cpp
 size_type max_size() const noexcept;
 ```
 *Returns:* `false`.
 ### Raw storage iterator <a id="storage.iterator">[[storage.iterator]]</a>
 `raw_storage_iterator` is provided to enable algorithms to store their
+results into uninitialized memory. The template parameter
 `OutputIterator` is required to have its `operator*` return an object
 for which `operator&` is defined and returns a pointer to `T`, and is
 also required to satisfy the requirements of an output iterator (
 [[output.iterators]]).
   class raw_storage_iterator
     : public iterator<output_iterator_tag,void,void,void,void> {
   public:
     explicit raw_storage_iterator(OutputIterator x);
+    raw_storage_iterator& operator*();
+    raw_storage_iterator& operator=(const T& element);
+    raw_storage_iterator& operator++();
+    raw_storage_iterator  operator++(int);
   };
 }
 ```
 ``` cpp
 *Effects:* Initializes the iterator to point to the same value to which
 `x` points.
 ``` cpp
+raw_storage_iterator& operator*();
 ```
 *Returns:* `*this`
 ``` cpp
+raw_storage_iterator& operator=(const T& element);
 ```
 *Effects:* Constructs a value from `element` at the location to which
 the iterator points.
 *Returns:* A reference to the iterator.
 ``` cpp
+raw_storage_iterator& operator++();
 ```
 *Effects:* Pre-increment: advances the iterator and returns a reference
 to the updated iterator.
 ``` cpp
+raw_storage_iterator operator++(int);
 ```
 *Effects:* Post-increment: advances the iterator and returns the old
 value of the iterator.
 *Requires:* The buffer shall have been previously allocated by
 `get_temporary_buffer`.
 ### Specialized algorithms <a id="specialized.algorithms">[[specialized.algorithms]]</a>
+All the iterators that are used as template parameters in the following
+algorithms are required to have their `operator*` return an object for
+which `operator&` is defined and returns a pointer to `T`. In the
+algorithm `uninitialized_copy`, the template parameter `InputIterator`
+is required to satisfy the requirements of an input iterator (
+[[input.iterators]]). In all of the following algorithms, the template
+parameter `ForwardIterator` is required to satisfy the requirements of a
+forward iterator ([[forward.iterators]]), and is required to have the
+property that no exceptions are thrown from increment, assignment,
+comparison, or indirection through valid iterators. In the following
+algorithms, if an exception is thrown there are no effects.
 #### `addressof` <a id="specialized.addressof">[[specialized.addressof]]</a>
 ``` cpp
 template <class T> T* addressof(T& r) noexcept;
   template<class T> struct default_delete<T[]>;
   template<class T, class D = default_delete<T>> class unique_ptr;
   template<class T, class D> class unique_ptr<T[], D>;
+  template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
+  template<class T> unique_ptr<T> make_unique(size_t n);
+  template<class T, class... Args> unspecified make_unique(Args&&...) = delete;
   template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
   template<class T1, class D1, class T2, class D2>
     bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
   template<class T1, class D1, class T2, class D2>
     unique_ptr& operator=(unique_ptr&& u) noexcept;
     template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
     unique_ptr& operator=(nullptr_t) noexcept;
     // [unique.ptr.single.observers], observers
+ add_lvalue_reference_t<T> operator*() const;
     pointer operator->() const noexcept;
     pointer get() const noexcept;
     deleter_type& get_deleter() noexcept;
     const deleter_type& get_deleter() const noexcept;
     explicit operator bool() const noexcept;
 for that deleter.
 If the deleter’s type `D` is not a reference type, `D` shall satisfy the
 requirements of `Destructible` (Table  [[destructible]]).
+If the type `remove_reference_t<D>::pointer` exists, then `unique_ptr<T,
+D>::pointer` shall be a synonym for `remove_reference_t<D>::pointer`.
+Otherwise `unique_ptr<T, D>::pointer` shall be a synonym for `T*`. The
+type `unique_ptr<T,
 D>::pointer` shall satisfy the requirements of `NullablePointer` (
 [[nullablepointer.requirements]]).
 Given an allocator type `X` ([[allocator.requirements]]) and letting
 `A` be a synonym for `allocator_traits<X>`, the types `A::pointer`,
 ```
 *Requires:* If `D` is not a reference type, `D` shall satisfy the
 requirements of `MoveAssignable` (Table  [[moveassignable]]) and
 assignment of the deleter from an rvalue of type `D` shall not throw an
+exception. Otherwise, `D` is a reference type; `remove_reference_t<D>`
+shall satisfy the `CopyAssignable` requirements and assignment of the
+deleter from an lvalue of type `D` shall not throw an exception.
 *Effects:* Transfers ownership from `u` to `*this` as if by calling
+`reset(u.release())` followed by
+`get_deleter() = std::forward<D>(u.get_deleter())`.
 *Returns:* `*this`.
 ``` cpp
 template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
 - `unique_ptr<U, E>::pointer` is implicitly convertible to `pointer` and
 - `U` is not an array type.
 *Effects:* Transfers ownership from `u` to `*this` as if by calling
+`reset(u.release())` followed by
+`get_deleter() = std::forward<E>(u.get_deleter())`.
 *Returns:* `*this`.
 ``` cpp
 unique_ptr& operator=(nullptr_t) noexcept;
 *Returns:* `*this`.
 ##### `unique_ptr` observers <a id="unique.ptr.single.observers">[[unique.ptr.single.observers]]</a>
 ``` cpp
+add_lvalue_reference_t<T> operator*() const;
 ```
 *Requires:* `get() != nullptr`.
 *Returns:* `*get()`.
 *Returns:* `get()[i]`.
 ##### `unique_ptr` modifiers <a id="unique.ptr.runtime.modifiers">[[unique.ptr.runtime.modifiers]]</a>
 ``` cpp
 void reset(nullptr_t p) noexcept;
 ```
+*Effects:* Equivalent to `reset(pointer())`.
+#### `unique_ptr` creation <a id="unique.ptr.create">[[unique.ptr.create]]</a>
+``` cpp
+template <class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `T` is not an array.
+*Returns:* `unique_ptr<T>(new T(std::forward<Args>(args)...))`.
+``` cpp
+template <class T> unique_ptr<T> make_unique(size_t n);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `T` is an array of unknown bound.
+*Returns:* `unique_ptr<T>(new remove_extent_t<T>[n]())`.
+``` cpp
+template <class T, class... Args> unspecified make_unique(Args&&...) = delete;
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `T` is an array of known bound.
 #### `unique_ptr` specialized algorithms <a id="unique.ptr.special">[[unique.ptr.special]]</a>
 ``` cpp
 template <class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
     // [util.smartptr.shared.const], constructors:
     constexpr shared_ptr() noexcept;
     template<class Y> explicit shared_ptr(Y* p);
     template<class Y, class D> shared_ptr(Y* p, D d);
     template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
+    template <class D> shared_ptr(nullptr_t p, D d);
+    template <class D, class A> shared_ptr(nullptr_t p, D d, A a);
     template<class Y> shared_ptr(const shared_ptr<Y>& r, T* p) noexcept;
     shared_ptr(const shared_ptr& r) noexcept;
     template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
     shared_ptr(shared_ptr&& r) noexcept;
     template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
 constexpr shared_ptr() noexcept;
 ```
 *Effects:* Constructs an *empty* `shared_ptr` object.
+*Postconditions:* `use_count() == 0 && get() == nullptr`.
 ``` cpp
 template<class Y> explicit shared_ptr(Y* p);
 ```
 To avoid the possibility of a dangling pointer, the user of this
 constructor must ensure that `p` remains valid at least until the
 ownership group of `r` is destroyed.
 This constructor allows creation of an *empty* `shared_ptr` instance
+with a non-null stored pointer.
 ``` cpp
 shared_ptr(const shared_ptr& r) noexcept;
 template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
 ```
+The second constructor shall not participate in overload resolution
+unless `Y*` is implicitly convertible to `T*`.
 *Effects:* If `r` is *empty*, constructs an *empty* `shared_ptr` object;
 otherwise, constructs a `shared_ptr` object that *shares ownership* with
 `r`.
 unless `Y*` is convertible to `T*`.
 *Effects:* Move-constructs a `shared_ptr` instance from `r`.
 *Postconditions:* `*this` shall contain the old value of `r`. `r` shall
+be *empty*. `r.get() == nullptr.`
 ``` cpp
 template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
 ```
 shall have well defined behavior, and shall not throw exceptions.
 *Effects:* Constructs a `shared_ptr` object that stores and *owns*
 `r.release()`.
+*Postconditions:* `use_count() == 1` `&&` `r.get() == nullptr`.
 *Throws:* `bad_alloc`, or an *implementation-defined* exception when a
 resource other than memory could not be obtained.
 If an exception is thrown, the constructor has no effect.
 *Returns:* `use_count() == 1`.
 `unique()` may be faster than `use_count()`. If you are using `unique()`
 to implement copy on write, do not rely on a specific value when
+`get() == nullptr`.
 ``` cpp
 explicit operator bool() const noexcept;
 ```
 *Postconditions:* `get() != 0 && use_count() == 1`
 *Throws:* `bad_alloc`, or an exception thrown from `A::allocate` or from
 the constructor of `T`.
+*Remarks:* Implementations should perform no more than one memory
+allocation. This provides efficiency equivalent to an intrusive smart
+pointer.
 These functions will typically allocate more memory than `sizeof(T)` to
 allow for internal bookkeeping structures such as the reference counts.
 ##### `shared_ptr` comparison <a id="util.smartptr.shared.cmp">[[util.smartptr.shared.cmp]]</a>
 ``` cpp
 template<class T, class U> bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
 ```
 *Returns:* `less<V>()(a.get(), b.get())`, where `V` is the composite
+pointer type (Clause  [[expr]]) of `T*` and `U*`.
 Defining a comparison operator allows `shared_ptr` objects to be used as
 keys in associative containers.
 ``` cpp
 ``` cpp
 template<class D, class T> D* get_deleter(const shared_ptr<T>& p) noexcept;
 ```
 *Returns:* If `p` *owns* a deleter `d` of type cv-unqualified `D`,
+returns `&d`; otherwise returns `nullptr`. The returned pointer remains
+valid as long as there exists a `shared_ptr` instance that owns `d`. It
+is unspecified whether the pointer remains valid longer than that. This
+can happen if the implementation doesn’t destroy the deleter until all
 `weak_ptr` instances that share ownership with `p` have been destroyed.
 ##### `shared_ptr` I/O <a id="util.smartptr.shared.io">[[util.smartptr.shared.io]]</a>
 ``` cpp
     // [util.smartptr.weak.const], constructors
     constexpr weak_ptr() noexcept;
     template<class Y> weak_ptr(shared_ptr<Y> const& r) noexcept;
     weak_ptr(weak_ptr const& r) noexcept;
     template<class Y> weak_ptr(weak_ptr<Y> const& r) noexcept;
+    weak_ptr(weak_ptr&& r) noexcept;
+    template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
     // [util.smartptr.weak.dest], destructor
     ~weak_ptr();
     // [util.smartptr.weak.assign], assignment
     weak_ptr& operator=(weak_ptr const& r) noexcept;
     template<class Y> weak_ptr& operator=(weak_ptr<Y> const& r) noexcept;
     template<class Y> weak_ptr& operator=(shared_ptr<Y> const& r) noexcept;
+    weak_ptr& operator=(weak_ptr&& r) noexcept;
+    template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
     // [util.smartptr.weak.mod], modifiers
     void swap(weak_ptr& r) noexcept;
     void reset() noexcept;
     // [util.smartptr.weak.obs], observers
     long use_count() const noexcept;
     bool expired() const noexcept;
     shared_ptr<T> lock() const noexcept;
+    template<class U> bool owner_before(shared_ptr<U> const& b) const;
+    template<class U> bool owner_before(weak_ptr<U> const& b) const;
   };
   // [util.smartptr.weak.spec], specialized algorithms
   template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 } // namespace std
 weak_ptr(const weak_ptr& r) noexcept;
 template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept;
 template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
 ```
+The second and third constructors shall not participate in overload
+resolution unless `Y*` is implicitly convertible to `T*`.
 *Effects:* If `r` is *empty*, constructs an *empty* `weak_ptr` object;
 otherwise, constructs a `weak_ptr` object that *shares ownership* with
 `r` and stores a copy of the pointer stored in `r`.
 *Postconditions:* `use_count() == r.use_count()`.
+``` cpp
+weak_ptr(weak_ptr&& r) noexcept;
+template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
+```
+The second constructor shall not participate in overload resolution
+unless `Y*` is implicitly convertible to `T*`.
+*Effects:* Move-constructs a `weak_ptr` instance from `r`.
+*Postconditions:* `*this` shall contain the old value of `r`. `r` shall
+be *empty*. `r.use_count() == 0`.
 ##### `weak_ptr` destructor <a id="util.smartptr.weak.dest">[[util.smartptr.weak.dest]]</a>
 ``` cpp
 ~weak_ptr();
 ```
 *Effects:* Equivalent to `weak_ptr(r).swap(*this)`.
 *Remarks:* The implementation may meet the effects (and the implied
 guarantees) via different means, without creating a temporary.
+*Returns:* `*this`.
+``` cpp
+weak_ptr& operator=(weak_ptr&& r) noexcept;
+template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
+```
+*Effects:* Equivalent to `weak_ptr(std::move(r)).swap(*this)`.
+*Returns:* `*this`.
 ##### `weak_ptr` modifiers <a id="util.smartptr.weak.mod">[[util.smartptr.weak.mod]]</a>
 ``` cpp
 void swap(weak_ptr& r) noexcept;
 ```
 ``` cpp
 shared_ptr<T> lock() const noexcept;
 ```
+*Returns:* `expired() ? shared_ptr<T>() : shared_ptr<T>(*this)`,
+executed atomically.
 ``` cpp
+template<class U> bool owner_before(shared_ptr<U> const& b) const;
+template<class U> bool owner_before(weak_ptr<U> const& b) const;
 ```
 *Returns:* An unspecified value such that
 - `x.owner_before(y)` defines a strict weak ordering as defined
 template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
+#### Class template `owner_less` <a id="util.smartptr.ownerless">[[util.smartptr.ownerless]]</a>
 The class template `owner_less` allows ownership-based mixed comparisons
 of shared and weak pointers.
 ``` cpp
 template<class T>
   bool atomic_compare_exchange_weak(
     shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
 ```
+*Requires:* `p` shall not be null and `v` shall not be null.
 *Returns:*
 `atomic_compare_exchange_weak_explicit(p, v, w, memory_order_seq_cst, memory_order_seq_cst)`.
 *Throws:* Nothing.
   bool atomic_compare_exchange_strong_explicit(
     shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w,
     memory_order success, memory_order failure);
 ```
+*Requires:* `p` shall not be null and `v` shall not be null.
 *Requires:* `failure` shall not be `memory_order_release`,
 `memory_order_acq_rel`, or stronger than `success`.
 *Effects:* If `*p` is equivalent to `*v`, assigns `w` to `*p` and has
 ``` cpp
 template <class T, class D> struct hash<unique_ptr<T, D> >;
 ```
+The template specialization shall meet the requirements of class
+template `hash` ([[unord.hash]]). For an object `p` of type `UP`, where
+`UP` is `unique_ptr<T, D>`, `hash<UP>()(p)` shall evaluate to the same
+value as `hash<typename UP::pointer>()(p.get())`.
+*Requires:* The specialization `hash<typename UP::pointer>` shall be
+well-formed and well-defined, and shall meet the requirements of class
+template `hash` ([[unord.hash]]).
 ``` cpp
 template <class T> struct hash<shared_ptr<T> >;
 ```
+The template specialization shall meet the requirements of class
+template `hash` ([[unord.hash]]). For an object `p` of type
 `shared_ptr<T>`, `hash<shared_ptr<T> >()(p)` shall evaluate to the same
 value as `hash<T*>()(p.get())`.
 ## Function objects <a id="function.objects">[[function.objects]]</a>
   template <class T> reference_wrapper<T> ref(reference_wrapper<T>) noexcept;
   template <class T> reference_wrapper<const T> cref(reference_wrapper<T>) noexcept;
   // [arithmetic.operations], arithmetic operations:
+  template <class T = void> struct plus;
+  template <class T = void> struct minus;
+  template <class T = void> struct multiplies;
+  template <class T = void> struct divides;
+  template <class T = void> struct modulus;
+  template <class T = void> struct negate;
+  template <> struct plus<void>;
+  template <> struct minus<void>;
+  template <> struct multiplies<void>;
+  template <> struct divides<void>;
+  template <> struct modulus<void>;
+  template <> struct negate<void>;
   // [comparisons], comparisons:
+  template <class T = void> struct equal_to;
+  template <class T = void> struct not_equal_to;
+  template <class T = void> struct greater;
+  template <class T = void> struct less;
+  template <class T = void> struct greater_equal;
+  template <class T = void> struct less_equal;
+  template <> struct equal_to<void>;
+  template <> struct not_equal_to<void>;
+  template <> struct greater<void>;
+  template <> struct less<void>;
+  template <> struct greater_equal<void>;
+  template <> struct less_equal<void>;
   // [logical.operations], logical operations:
+  template <class T = void> struct logical_and;
+  template <class T = void> struct logical_or;
+  template <class T = void> struct logical_not;
+  template <> struct logical_and<void>;
+  template <> struct logical_or<void>;
+  template <> struct logical_not<void>;
   // [bitwise.operations], bitwise operations:
+  template <class T = void> struct bit_and;
+  template <class T = void> struct bit_or;
+  template <class T = void> struct bit_xor;
+  template <class T = void> struct bit_not;
+  template <> struct bit_and<void>;
+  template <> struct bit_or<void>;
+  template <> struct bit_xor<void>;
+  template <> struct bit_not<void>;
   // [negators], negators:
   template <class Predicate> class unary_negate;
   template <class Predicate>
+ constexpr unary_negate<Predicate> not1(const Predicate&);
   template <class Predicate> class binary_negate;
   template <class Predicate>
+ constexpr binary_negate<Predicate> not2(const Predicate&);
+  // [func.bind], bind:
   template<class T> struct is_bind_expression;
   template<class T> struct is_placeholder;
   template<class F, class... BoundArgs>
     unspecified bind(F&&, BoundArgs&&...);
   template <class S, class T, class A>
     const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);
   // [func.memfn], member function adaptors:
   template<class R, class T> unspecified mem_fn(R T::*);
   // [func.wrap] polymorphic function wrappers:
   class bad_function_call;
   template<class> class function; // undefined
   template<class R, class... ArgTypes>
     bool operator!=(const function<R(ArgTypes...)>&, nullptr_t);
   template<class R, class... ArgTypes>
     bool operator!=(nullptr_t, const function<R(ArgTypes...)>&);
+  // [unord.hash], hash function primary template:
   template <class T> struct hash;
   // Hash function specializations
   template <> struct hash<bool>;
   template <> struct hash<char>;
 ``` cpp
 transform(a.begin(), a.end(), a.begin(), negate<double>());
 ```
 To enable adaptors and other components to manipulate function objects
+that take one or two arguments many of the function objects in this
+clause correspondingly provide typedefs `argument_type` and
+`result_type` for function objects that take one argument and
+`first_argument_type`, `second_argument_type`, and `result_type` for
+function objects that take two arguments.
 ### Definitions <a id="func.def">[[func.def]]</a>
 The following definitions apply to this Clause:
     typedef see below second_argument_type;      // not always defined
     // construct/copy/destroy
     reference_wrapper(T&) noexcept;
     reference_wrapper(T&&) = delete;     // do not bind to temporary objects
+    reference_wrapper(const reference_wrapper& x) noexcept;
     // assignment
+    reference_wrapper& operator=(const reference_wrapper& x) noexcept;
     // access
     operator T& () const noexcept;
     T& get() const noexcept;
     // invocation
     template <class... ArgTypes>
+ result_of_t<T&(ArgTypes&&...)>
     operator() (ArgTypes&&...) const;
   };
 }
 ```
 `reference_wrapper<T>` has a weak result type ([[func.require]]). If
 `T` is a function type, `result_type` shall be a synonym for the return
 type of `T`.
+The template specialization `reference_wrapper<T>` shall define a nested
 type named `argument_type` as a synonym for `T1` only if the type `T` is
 any of the following:
 - a function type or a pointer to function type taking one argument of
   type `T1`
 - a function type or a pointer to function type taking two arguments of
   types `T1` and `T2`
 - a pointer to member function `R T0::f(T2)` *cv* (where *cv* represents
   the member function’s cv-qualifiers); the type `T1` is *cv* `T0*`
 - a class type with member types `first_argument_type` and
+  `second_argument_type`; the type `T1` is `T::first_argument_type` and
   the type `T2` is `T::second_argument_type`.
 #### `reference_wrapper` construct/copy/destroy <a id="refwrap.const">[[refwrap.const]]</a>
 ``` cpp
 *Effects:* Constructs a `reference_wrapper` object that stores a
 reference to `t`.
 ``` cpp
+reference_wrapper(const reference_wrapper& x) noexcept;
 ```
 *Effects:* Constructs a `reference_wrapper` object that stores a
 reference to `x.get()`.
 #### `reference_wrapper` assignment <a id="refwrap.assign">[[refwrap.assign]]</a>
 ``` cpp
+reference_wrapper& operator=(const reference_wrapper& x) noexcept;
 ```
 *Postconditions:* `*this` stores a reference to `x.get()`.
 #### `reference_wrapper` access <a id="refwrap.access">[[refwrap.access]]</a>
 #### reference_wrapper invocation <a id="refwrap.invoke">[[refwrap.invoke]]</a>
 ``` cpp
 template <class... ArgTypes>
+ result_of_t<T&(ArgTypes&&... )>
     operator()(ArgTypes&&... args) const;
 ```
 *Returns:*
 *`INVOKE`*`(get(), std::forward<ArgTypes>(args)...)`. ([[func.require]])
 The library provides basic function object classes for all of the
 arithmetic operators in the language ([[expr.mul]], [[expr.add]]).
 ``` cpp
+template <class T = void> struct plus {
+ constexpr T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x + y`.
 ``` cpp
+template <class T = void> struct minus {
+ constexpr T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x - y`.
 ``` cpp
+template <class T = void> struct multiplies {
+ constexpr T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x * y`.
 ``` cpp
+template <class T = void> struct divides {
+ constexpr T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x / y`.
 ``` cpp
+template <class T = void> struct modulus {
+ constexpr T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x % y`.
 ``` cpp
+template <class T = void> struct negate {
+ constexpr T operator()(const T& x) const;
   typedef T argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `-x`.
+``` cpp
+template <> struct plus<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) + std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) + std::forward<U>(u)`.
+``` cpp
+template <> struct minus<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) - std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) - std::forward<U>(u)`.
+``` cpp
+template <> struct multiplies<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) * std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) * std::forward<U>(u)`.
+``` cpp
+template <> struct divides<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) / std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) / std::forward<U>(u)`.
+``` cpp
+template <> struct modulus<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) % std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) % std::forward<U>(u)`.
+``` cpp
+template <> struct negate<void> {
+  template <class T> constexpr auto operator()(T&& t) const
+    -> decltype(-std::forward<T>(t));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `-std::forward<T>(t)`.
 ### Comparisons <a id="comparisons">[[comparisons]]</a>
 The library provides basic function object classes for all of the
 comparison operators in the language ([[expr.rel]], [[expr.eq]]).
 ``` cpp
+template <class T = void> struct equal_to {
+ constexpr bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x == y`.
 ``` cpp
+template <class T = void> struct not_equal_to {
+ constexpr bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x != y`.
 ``` cpp
+template <class T = void> struct greater {
+ constexpr bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x > y`.
 ``` cpp
+template <class T = void> struct less {
+ constexpr bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x < y`.
 ``` cpp
+template <class T = void> struct greater_equal {
+ constexpr bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x >= y`.
 ``` cpp
+template <class T = void> struct less_equal {
+ constexpr bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x <= y`.
+``` cpp
+template <> struct equal_to<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) == std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) == std::forward<U>(u)`.
+``` cpp
+template <> struct not_equal_to<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) != std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) != std::forward<U>(u)`.
+``` cpp
+template <> struct greater<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) > std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) > std::forward<U>(u)`.
+``` cpp
+template <> struct less<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) < std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) < std::forward<U>(u)`.
+``` cpp
+template <> struct greater_equal<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) >= std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) >= std::forward<U>(u)`.
+``` cpp
+template <> struct less_equal<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) <= std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) <= std::forward<U>(u)`.
 For templates `greater`, `less`, `greater_equal`, and `less_equal`, the
 specializations for any pointer type yield a total order, even if the
 built-in operators `<`, `>`, `<=`, `>=` do not.
 ### Logical operations <a id="logical.operations">[[logical.operations]]</a>
 The library provides basic function object classes for all of the
 logical operators in the language ([[expr.log.and]], [[expr.log.or]],
 [[expr.unary.op]]).
 ``` cpp
+template <class T = void> struct logical_and {
+ constexpr bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x && y`.
 ``` cpp
+template <class T = void> struct logical_or {
+ constexpr bool operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `x || y`.
 ``` cpp
+template <class T = void> struct logical_not {
+ constexpr bool operator()(const T& x) const;
   typedef T argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `!x`.
+``` cpp
+template <> struct logical_and<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) && std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) && std::forward<U>(u)`.
+``` cpp
+template <> struct logical_or<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) || std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) || std::forward<U>(u)`.
+``` cpp
+template <> struct logical_not<void> {
+  template <class T> constexpr auto operator()(T&& t) const
+    -> decltype(!std::forward<T>(t));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `!std::forward<T>(t)`.
 ### Bitwise operations <a id="bitwise.operations">[[bitwise.operations]]</a>
 The library provides basic function object classes for all of the
 bitwise operators in the language ([[expr.bit.and]], [[expr.or]],
+[[expr.xor]], [[expr.unary.op]]).
 ``` cpp
+template <class T = void> struct bit_and {
+ constexpr T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x & y`.
 ``` cpp
+template <class T = void> struct bit_or {
+ constexpr T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x | y`.
 ``` cpp
+template <class T = void> struct bit_xor {
+ constexpr T operator()(const T& x, const T& y) const;
   typedef T first_argument_type;
   typedef T second_argument_type;
   typedef T result_type;
 };
 ```
 `operator()` returns `x ^ y`.
+``` cpp
+template <class T = void> struct bit_not {
+  constexpr T operator()(const T& x) const;
+  typedef T argument_type;
+  typedef T result_type;
+};
+```
+`operator()` returns `~x`.
+``` cpp
+template <> struct bit_and<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) & std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) & std::forward<U>(u)`.
+``` cpp
+template <> struct bit_or<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) | std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) | std::forward<U>(u)`.
+``` cpp
+template <> struct bit_xor<void> {
+  template <class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) ^ std::forward<U>(u));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `std::forward<T>(t) ^ std::forward<U>(u)`.
+``` cpp
+template <> struct bit_not<void> {
+  template <class T> constexpr auto operator()(T&& t) const
+    -> decltype(~std::forward<T>(t));
+  typedef unspecified is_transparent;
+};
+```
+`operator()` returns `~std::forward<T>(t)`.
 ### Negators <a id="negators">[[negators]]</a>
 Negators `not1` and `not2` take a unary and a binary predicate,
 respectively, and return their complements ([[expr.unary.op]]).
 ``` cpp
 template <class Predicate>
   class unary_negate {
 public:
+ constexpr explicit unary_negate(const Predicate& pred);
+ constexpr bool operator()(const typename Predicate::argument_type& x) const;
   typedef typename Predicate::argument_type argument_type;
   typedef bool result_type;
 };
 ```
 `operator()` returns `!pred(x)`.
 ``` cpp
 template <class Predicate>
+ constexpr unary_negate<Predicate> not1(const Predicate& pred);
 ```
 *Returns:* `unary_negate<Predicate>(pred)`.
 ``` cpp
 template <class Predicate>
   class binary_negate {
   public:
+ constexpr explicit binary_negate(const Predicate& pred);
+ constexpr bool operator()(const typename Predicate::first_argument_type& x,
         const typename Predicate::second_argument_type& y) const;
   typedef typename Predicate::first_argument_type first_argument_type;
   typedef typename Predicate::second_argument_type second_argument_type;
   typedef bool result_type;
   };
 `operator()` returns `!pred(x,y)`.
 ``` cpp
 template <class Predicate>
+ constexpr binary_negate<Predicate> not2(const Predicate& pred);
 ```
 *Returns:* `binary_negate<Predicate>(pred)`.
+### Function object binders <a id="func.bind">[[func.bind]]</a>
 This subclause describes a uniform mechanism for binding arguments of
 callable objects.
+#### Class template `is_bind_expression` <a id="func.bind.isbind">[[func.bind.isbind]]</a>
 ``` cpp
 namespace std {
+  template<class T> struct is_bind_expression; // see below
 }
 ```
 `is_bind_expression` can be used to detect function objects generated by
+`bind`. `bind` uses `is_bind_expression` to detect subexpressions.
+Instantiations of the `is_bind_expression` template shall meet the
+UnaryTypeTrait requirements ([[meta.rqmts]]). The implementation shall
+provide a definition that has a BaseCharacteristic of `true_type` if `T`
+is a type returned from `bind`, otherwise it shall have a
+BaseCharacteristic of `false_type`. A program may specialize this
+template for a user-defined type `T` to have a BaseCharacteristic of
+`true_type` to indicate that `T` should be treated as a subexpression in
+a `bind` call.
+#### Class template `is_placeholder` <a id="func.bind.isplace">[[func.bind.isplace]]</a>
+``` cpp
+namespace std {
+  template<class T> struct is_placeholder; // see below
+}
+```
 `is_placeholder` can be used to detect the standard placeholders `_1`,
 `_2`, and so on. `bind` uses `is_placeholder` to detect placeholders.
+Instantiations of the `is_placeholder` template shall meet the
+UnaryTypeTrait requirements ([[meta.rqmts]]). The implementation shall
+provide a definition that has the BaseCharacteristic of
+`integral_constant<int, J>` if `T` is the type of
+`std::placeholders::_J`, otherwise it shall have a BaseCharacteristic of
+`integral_constant<int, 0>`. A program may specialize this template for
+a user-defined type `T` to have a BaseCharacteristic of
+`integral_constant<int, N>` with `N > 0` to indicate that `T` should be
+treated as a placeholder type.
+#### Function template `bind` <a id="func.bind.bind">[[func.bind.bind]]</a>
 In the text that follows, the following names have the following
 meanings:
+- `FD` is the type `decay_t<F>`,
 - `fd` is an lvalue of type `FD` constructed from `std::forward<F>(f)`,
+- `Ti` is the iᵗʰ type in the template parameter pack `BoundArgs`,
+- `TiD` is the type `decay_t<Ti>`,
 - `ti` is the iᵗʰ argument in the function parameter pack `bound_args`,
 - `tid` is an lvalue of type `TiD` constructed from
   `std::forward<Ti>(ti)`,
 - `Uj` is the jᵗʰ deduced type of the `UnBoundArgs&&...` parameter of
   the forwarding call wrapper, and
 expression for some values *w1, w2, ..., wN*, where
 `N == sizeof...(bound_args)`.
 *Returns:* A forwarding call wrapper `g` with a weak result
 type ([[func.require]]). The effect of `g(u1, u2, ..., uM)` shall be
+*`INVOKE`*`(fd, std::forward<V1>(v1), std::forward<V2>(v2), ..., std::forward<VN>(vN), result_of_t<FD `*`cv`*` & (V1, V2, ..., VN)>)`,
 where *`cv`* represents the *cv*-qualifiers of `g` and the values and
 types of the bound arguments `v1, v2, ..., vN` are determined as
 specified below. The copy constructor and move constructor of the
 forwarding call wrapper shall throw an exception if and only if the
 corresponding constructor of `FD` or of any of the types `TiD` throws an
 *`INVOKE`*`(fd, w1, w2, ..., wN)` shall be a valid expression for some
 values *w1, w2, ..., wN*, where `N == sizeof...(bound_args)`.
 *Returns:* A forwarding call wrapper `g` with a nested type
 `result_type` defined as a synonym for `R`. The effect of
+`g(u1, u2, ..., uM)` shall be
+*`INVOKE`*`(fd, std::forward<V1>(v1), std::forward<V2>(v2), ..., std::forward<VN>(vN), R)`,
 where the values and types of the bound arguments `v1, v2, ..., vN` are
 determined as specified below. The copy constructor and move constructor
 of the forwarding call wrapper shall throw an exception if and only if
 the corresponding constructor of `FD` or of any of the types `TiD`
 throws an exception.
 - if `TiD` is `reference_wrapper<T>`, the argument is `tid.get()` and
   its type `Vi` is `T&`;
 - if the value of `is_bind_expression<TiD>::value` is `true`, the
   argument is `tid(std::forward<Uj>({}uj)...)` and its type `Vi` is
+  `result_of_t<TiD cv & (Uj&&...)>&&`;
 - if the value `j` of `is_placeholder<TiD>::value` is not zero, the
   argument is `std::forward<Uj>(uj)` and its type `Vi` is `Uj&&`;
 - otherwise, the value is `tid` and its type `Vi` is `TiD cv &`.
+#### Placeholders <a id="func.bind.place">[[func.bind.place]]</a>
 ``` cpp
 namespace std {
   namespace placeholders {
     // M is the implementation-defined number of placeholders
 placeholders’ copy assignment operators shall not throw exceptions.
 ### Function template `mem_fn` <a id="func.memfn">[[func.memfn]]</a>
 ``` cpp
+template<class R, class T> unspecified mem_fn(R T::* pm);
 ```
 *Returns:* A simple call wrapper ([[func.def]]) `fn` such that the
 expression `fn(t, a2, ..., aN)` is equivalent to
 *`INVOKE`*`(pm, t, a2, ..., aN)` ([[func.require]]). `fn` shall have a
   template<class R, class... ArgTypes>
   class function<R(ArgTypes...)> {
   public:
     typedef R result_type;
+    typedef T1 argument_type;           // only if sizeof...(ArgTypes) == 1 and
                                         // the type in ArgTypes is T1
+    typedef T1 first_argument_type;     // only if sizeof...(ArgTypes) == 2 and
                                         // ArgTypes contains T1 and T2
+    typedef T2 second_argument_type;    // only if sizeof...(ArgTypes) == 2 and
                                         // ArgTypes contains T1 and T2
     // [func.wrap.func.con], construct/copy/destroy:
     function() noexcept;
     function(nullptr_t) noexcept;
     // [func.wrap.func.inv], function invocation:
     R operator()(ArgTypes...) const;
     // [func.wrap.func.targ], function target access:
     const std::type_info& target_type() const noexcept;
+    template<class T>       T* target() noexcept;
+    template<class T> const T* target() const noexcept;
   };
   // [func.wrap.func.nullptr], Null pointer comparisons:
   template <class R, class... ArgTypes>
 ``` cpp
 template<class F> function(F f);
 template <class F, class A> function(allocator_arg_t, const A& a, F f);
 ```
+*Requires:* `F` shall be `CopyConstructible`.
+*Remarks:* These constructors shall not participate in overload
+resolution unless `f` is Callable ([[func.wrap.func]]) for argument
+types `ArgTypes...` and return type `R`.
 *Postconditions:* `!*this` if any of the following hold:
+- `f` is a null function pointer value.
+- `f` is a null member pointer value.
+- `F` is an instance of the `function` class template, and `!f`.
 Otherwise, `*this` targets a copy of `f` initialized with
 `std::move(f)`. Implementations are encouraged to avoid the use of
 dynamically allocated memory for small callable objects, for example,
 where `f`’s target is an object holding only a pointer or reference to
 ``` cpp
 function& operator=(nullptr_t);
 ```
+*Effects:* If `*this != nullptr`, destroys the target of `this`.
 *Postconditions:* `!(*this)`.
 *Returns:* `*this`
 *Effects:* `function(std::forward<F>(f)).swap(*this);`
 *Returns:* `*this`
+*Remarks:* This assignment operator shall not participate in overload
+resolution unless `declval<typename decay<F>::type&>()` is
+Callable ([[func.wrap.func]]) for argument types `ArgTypes...` and
+return type `R`.
 ``` cpp
 template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ```
 *Effects:* `function(f).swap(*this);`
 ``` cpp
 ~function();
 ```
+*Effects:* If `*this != nullptr`, destroys the target of `this`.
 ##### `function` modifiers <a id="func.wrap.func.mod">[[func.wrap.func.mod]]</a>
 ``` cpp
 void swap(function& other) noexcept;
 *Returns:* If `*this` has a target of type `T`, `typeid(T)`; otherwise,
 `typeid(void)`.
 ``` cpp
+template<class T>       T* target() noexcept;
+template<class T> const T* target() const noexcept;
 ```
 *Requires:* `T` shall be a type that is Callable ([[func.wrap.func]])
 for parameter types `ArgTypes` and return type `R`.
+*Returns:* If `target_type() == typeid(T)` a pointer to the stored
 function target; otherwise a null pointer.
 ##### null pointer comparison operators <a id="func.wrap.func.nullptr">[[func.wrap.func.nullptr]]</a>
 ``` cpp
 ### Class template `hash` <a id="unord.hash">[[unord.hash]]</a>
 The unordered associative containers defined in [[unord]] use
 specializations of the class template `hash` as the default hash
 function. For all object types `Key` for which there exists a
+specialization `hash<Key>`, and for all enumeration types (
+[[dcl.enum]]) `Key`, the instantiation `hash<Key>` shall:
 - satisfy the `Hash` requirements ([[hash.requirements]]), with `Key`
   as the function call argument type, the `DefaultConstructible`
   requirements (Table  [[defaultconstructible]]), the `CopyAssignable`
   requirements (Table  [[copyassignable]]),
 template <> struct hash<double>;
 template <> struct hash<long double>;
 template <class T> struct hash<T*>;
 ```
+The template specializations shall meet the requirements of class
+template `hash` ([[unord.hash]]).
 ## Metaprogramming and type traits <a id="meta">[[meta]]</a>
 This subclause describes components used by C++programs, particularly in
 templates, to support the widest possible range of types, optimise
 BinaryTypeTrait.
 A *TransformationTrait* modifies a property of a type. It shall be a
 class template that takes one template type argument and, optionally,
 additional arguments that help define the modification. It shall define
+a publicly accessible nested type named `type`, which shall be a synonym
+for the modified type.
 ### Header `<type_traits>` synopsis <a id="meta.type.synop">[[meta.type.synop]]</a>
 ``` cpp
 namespace std {
   typedef integral_constant<bool, true>  true_type;
   typedef integral_constant<bool, false> false_type;
   // [meta.unary.cat], primary type categories:
   template <class T> struct is_void;
+  template <class T> struct is_null_pointer;
   template <class T> struct is_integral;
   template <class T> struct is_floating_point;
   template <class T> struct is_array;
   template <class T> struct is_pointer;
   template <class T> struct is_lvalue_reference;
   template <class T> struct is_pod;
   template <class T> struct is_literal_type;
   template <class T> struct is_empty;
   template <class T> struct is_polymorphic;
   template <class T> struct is_abstract;
+  template <class T> struct is_final;
   template <class T> struct is_signed;
   template <class T> struct is_unsigned;
   template <class T, class... Args> struct is_constructible;
   template <class T> struct remove_cv;
   template <class T> struct add_const;
   template <class T> struct add_volatile;
   template <class T> struct add_cv;
+  template <class T>
+    using remove_const_t    = typename remove_const<T>::type;
+  template <class T>
+    using remove_volatile_t = typename remove_volatile<T>::type;
+  template <class T>
+    using remove_cv_t       = typename remove_cv<T>::type;
+  template <class T>
+    using add_const_t       = typename add_const<T>::type;
+  template <class T>
+    using add_volatile_t    = typename add_volatile<T>::type;
+  template <class T>
+    using add_cv_t          = typename add_cv<T>::type;
   // [meta.trans.ref], reference modifications:
   template <class T> struct remove_reference;
   template <class T> struct add_lvalue_reference;
   template <class T> struct add_rvalue_reference;
+  template <class T>
+    using remove_reference_t     = typename remove_reference<T>::type;
+  template <class T>
+    using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
+  template <class T>
+    using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
   // [meta.trans.sign], sign modifications:
   template <class T> struct make_signed;
   template <class T> struct make_unsigned;
+  template <class T>
+    using make_signed_t   = typename make_signed<T>::type;
+  template <class T>
+    using make_unsigned_t = typename make_unsigned<T>::type;
   // [meta.trans.arr], array modifications:
   template <class T> struct remove_extent;
   template <class T> struct remove_all_extents;
+  template <class T>
+    using remove_extent_t      = typename remove_extent<T>::type;
+  template <class T>
+    using remove_all_extents_t = typename remove_all_extents<T>::type;
   // [meta.trans.ptr], pointer modifications:
   template <class T> struct remove_pointer;
   template <class T> struct add_pointer;
+  template <class T>
+    using remove_pointer_t = typename remove_pointer<T>::type;
+  template <class T>
+    using add_pointer_t    = typename add_pointer<T>::type;
   // [meta.trans.other], other transformations:
   template <std::size_t Len,
             std::size_t Align = default-alignment>   // see [meta.trans.other]
     struct aligned_storage;
   template <std::size_t Len, class... Types> struct aligned_union;
   template <bool, class T, class F> struct conditional;
   template <class... T> struct common_type;
   template <class T> struct underlying_type;
   template <class> class result_of;   // not defined
   template <class F, class... ArgTypes> class result_of<F(ArgTypes...)>;
+  template <std::size_t Len,
+            std::size_t Align = default-alignment > // see [meta.trans.other]
+    using aligned_storage_t = typename aligned_storage<Len,Align>::type;
+  template <std::size_t Len, class... Types>
+    using aligned_union_t   = typename aligned_union<Len,Types...>::type;
+  template <class T>
+    using decay_t           = typename decay<T>::type;
+  template <bool b, class T = void>
+    using enable_if_t       = typename enable_if<b,T>::type;
+  template <bool b, class T, class F>
+    using conditional_t     = typename conditional<b,T,F>::type;
+  template <class... T>
+    using common_type_t     = typename common_type<T...>::type;
+  template <class T>
+    using underlying_type_t = typename underlying_type<T>::type;
+  template <class T>
+    using result_of_t       = typename result_of<T>::type;
 } // namespace std
 ```
 The behavior of a program that adds specializations for any of the class
 templates defined in this subclause is undefined unless otherwise
   template <class T, T v>
   struct integral_constant {
     static constexpr T value = v;
     typedef T value_type;
     typedef integral_constant<T,v> type;
+    constexpr operator value_type() const noexcept { return value; }
+    constexpr value_type operator()() const noexcept { return value; }
   };
   typedef integral_constant<bool, true> true_type;
   typedef integral_constant<bool, false> false_type;
 }
 ```
 is_const<int[3]>::value                 // false
 is_const<const int[3]>::value           // true
 ```
 ``` cpp
+remove_const_t<const volatile int>  // volatile int
+remove_const_t<const int* const>    // const int*
+remove_const_t<const int&>          // const int&
+remove_const_t<const int[3]>        // int[3]
+```
+``` cpp
+// Given:
+struct P final { };
+union U1 { };
+union U2 final { };
+// the following assertions hold:
+static_assert(!is_final<int>::value, "Error!");
+static_assert( is_final<P>::value, "Error!");
+static_assert(!is_final<U1>::value, "Error!");
+static_assert( is_final<U2>::value, "Error!");
 ```
 Given the following function prototype:
 ``` cpp
 template <class T>
+ add_rvalue_reference_t<T> create() noexcept;
 ```
 the predicate condition for a template specialization
 `is_constructible<T, Args...>` shall be satisfied if and only if the
 following variable definition would be well-formed for some invented
 ### Type property queries <a id="meta.unary.prop.query">[[meta.unary.prop.query]]</a>
 This sub-clause contains templates that may be used to query properties
 of types at compile time.
+Each of these templates shall be a `UnaryTypeTrait` ([[meta.rqmts]])
+with a `BaseCharacteristic` of `integral_constant<size_t, Value>`.
 ``` cpp
 // the following assertions hold:
 assert(rank<int>::value == 0);
 assert(rank<int[2]>::value == 1);
 assert(rank<int[][4]>::value == 2);
 Given the following function prototype:
 ``` cpp
 template <class T>
+ add_rvalue_reference_t<T> create() noexcept;
 ```
 the predicate condition for a template specialization
 `is_convertible<From, To>` shall be satisfied if and only if the return
 expression in the following code would be well-formed, including any
 #### Array modifications <a id="meta.trans.arr">[[meta.trans.arr]]</a>
 ``` cpp
 // the following assertions hold:
+assert((is_same<remove_extent_t<int>, int>::value));
+assert((is_same<remove_extent_t<int[2]>, int>::value));
+assert((is_same<remove_extent_t<int[2][3]>, int[3]>::value));
+assert((is_same<remove_extent_t<int[][3]>, int[3]>::value));
 ```
 ``` cpp
 // the following assertions hold:
+assert((is_same<remove_all_extents_t<int>, int>::value));
+assert((is_same<remove_all_extents_t<int[2]>, int>::value));
+assert((is_same<remove_all_extents_t<int[2][3]>, int>::value));
+assert((is_same<remove_all_extents_t<int[][3]>, int>::value));
 ```
 #### Pointer modifications <a id="meta.trans.ptr">[[meta.trans.ptr]]</a>
 #### Other transformations <a id="meta.trans.other">[[meta.trans.other]]</a>
 ``` cpp
 template <class ...T> struct common_type;
 template <class T>
 struct common_type<T> {
+  typedef decay_t<T> type;
 };
 template <class T, class U>
 struct common_type<T, U> {
+  typedef decay_t<decltype(true ? declval<T>() : declval<U>())> type;
 };
 template <class T, class U, class... V>
 struct common_type<T, U, V...> {
+  typedef common_type_t<common_type_t<T, U>, V...> type;
 };
 ```
 Given these definitions:
 ```
 the following assertions will hold:
 ``` cpp
+static_assert(is_same<result_of_t<S(int)>, short>::value, "Error!");
+static_assert(is_same<result_of_t<S&(unsigned char, int&)>, double>::value, "Error!");
+static_assert(is_same<result_of_t<PF1()>, bool>::value, "Error!");
+static_assert(is_same<result_of_t<PMF(unique_ptr<S>, int)>, void>::value, "Error!");
+static_assert(is_same<result_of_t<PMD(S)>, char&&>::value, "Error!");
+static_assert(is_same<result_of_t<PMD(const S*)>, const char&>::value, "Error!");
 ```
 ## Compile-time rational arithmetic <a id="ratio">[[ratio]]</a>
 ### In general <a id="ratio.general">[[ratio.general]]</a>
 This subclause describes the ratio library. It provides a class template
 `ratio` which exactly represents any finite rational number with a
 numerator and denominator representable by compile-time constants of
 type `intmax_t`.
+Throughout this subclause, the names of template parameters are used to
+express type requirements. If a template parameter is named `R1` or
+`R2`, and the template argument is not a specialization of the `ratio`
+template, the program is ill-formed.
 ### Header `<ratio>` synopsis <a id="ratio.syn">[[ratio.syn]]</a>
 ``` cpp
 namespace std {
   template <class R1, class R2> struct ratio_less_equal;
   template <class R1, class R2> struct ratio_greater;
   template <class R1, class R2> struct ratio_greater_equal;
   // [ratio.si], convenience SI typedefs
+  typedef ratio<1, 1'000'000'000'000'000'000'000'000> yocto;  // see below
+  typedef ratio<1,     1'000'000'000'000'000'000'000> zepto;  // see below
+  typedef ratio<1,         1'000'000'000'000'000'000> atto;
+  typedef ratio<1,             1'000'000'000'000'000> femto;
+  typedef ratio<1,                 1'000'000'000'000> pico;
+  typedef ratio<1,                     1'000'000'000> nano;
+  typedef ratio<1,                         1'000'000> micro;
+  typedef ratio<1,                             1'000> milli;
   typedef ratio<1,                               100> centi;
   typedef ratio<1,                                10> deci;
   typedef ratio<                               10, 1> deca;
   typedef ratio<                              100, 1> hecto;
+  typedef ratio<                            1'000, 1> kilo;
+  typedef ratio<                        1'000'000, 1> mega;
+  typedef ratio<                    1'000'000'000, 1> giga;
+  typedef ratio<                1'000'000'000'000, 1> tera;
+  typedef ratio<            1'000'000'000'000'000, 1> peta;
+  typedef ratio<        1'000'000'000'000'000'000, 1> exa;
+  typedef ratio<    1'000'000'000'000'000'000'000, 1> zetta;  // see below
+  typedef ratio<1'000'000'000'000'000'000'000'000, 1> yotta;  // see below
 }
 ```
 ### Class template `ratio` <a id="ratio.ratio">[[ratio.ratio]]</a>
 ``` cpp
 namespace std {
   template <intmax_t N, intmax_t D = 1>
   class ratio {
   public:
     static constexpr intmax_t num;
     static constexpr intmax_t den;
+    typedef ratio<num, den> type;
   };
 }
 ```
 If the template argument `D` is zero or the absolute values of either of
 template <class Rep> struct treat_as_floating_point;
 template <class Rep> struct duration_values;
 // [time.duration.nonmember], duration arithmetic
 template <class Rep1, class Period1, class Rep2, class Period2>
+ common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   constexpr operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period1, class Rep2, class Period2>
+ common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   constexpr operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period, class Rep2>
+  duration<common_type_t<Rep1, Rep2>, Period>
   constexpr operator*(const duration<Rep1, Period>& d, const Rep2& s);
 template <class Rep1, class Rep2, class Period>
+  duration<common_type_t<Rep1, Rep2>, Period>
   constexpr operator*(const Rep1& s, const duration<Rep2, Period>& d);
 template <class Rep1, class Period, class Rep2>
+  duration<common_type_t<Rep1, Rep2>, Period>
   constexpr operator/(const duration<Rep1, Period>& d, const Rep2& s);
 template <class Rep1, class Period1, class Rep2, class Period2>
+ common_type_t<Rep1, Rep2>
   constexpr operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period, class Rep2>
+  duration<common_type_t<Rep1, Rep2>, Period>
   constexpr operator%(const duration<Rep1, Period>& d, const Rep2& s);
 template <class Rep1, class Period1, class Rep2, class Period2>
+ common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   constexpr operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 // [time.duration.comparisons], duration comparisons
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr bool operator==(const duration<Rep1, Period1>& lhs,
 typedef duration<signed integer type of at least 29 bits, ratio<  60>> minutes;
 typedef duration<signed integer type of at least 23 bits, ratio<3600>> hours;
 // [time.point.nonmember], time_point arithmetic
 template <class Clock, class Duration1, class Rep2, class Period2>
+ constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
   operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period1, class Clock, class Duration2>
+ constexpr time_point<Clock, common_type_t<duration<Rep1, Period1>, Duration2>>
   operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Rep2, class Period2>
+ constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
   operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Clock, class Duration1, class Duration2>
+ constexpr common_type_t<Duration1, Duration2>
   operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 // [time.point.comparisons] time_point comparisons
 template <class Clock, class Duration1, class Duration2>
+ constexpr bool operator==(const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
+ constexpr bool operator!=(const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
+ constexpr bool operator< (const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
+ constexpr bool operator<=(const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
+ constexpr bool operator> (const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
+ constexpr bool operator>=(const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 // [time.point.cast], time_point_cast
 template <class ToDuration, class Clock, class Duration>
+ constexpr time_point<Clock, ToDuration>
+  time_point_cast(const time_point<Clock, Duration>& t);
 // [time.clock], clocks
 class system_clock;
 class steady_clock;
 class high_resolution_clock;
 }  // namespace chrono
+inline namespace literals {
+inline namespace chrono_literals {
+// ~[time.duration.literals], suffixes for duration literals
+constexpr chrono::hours                                 operator "" h(unsigned long long);
+constexpr chrono::duration<unspecified, ratio<3600,1>> operator "" h(long double);
+constexpr chrono::minutes                               operator "" min(unsigned long long);
+constexpr chrono::duration<unspecified, ratio<60,1>>   operator "" min(long double);
+constexpr chrono::seconds                               operator "" s(unsigned long long);
+constexpr chrono::duration<unspecified>                operator "" s(long double);
+constexpr chrono::milliseconds                          operator "" ms(unsigned long long);
+constexpr chrono::duration<unspecified, milli>         operator "" ms(long double);
+constexpr chrono::microseconds                          operator "" us(unsigned long long);
+constexpr chrono::duration<unspecified, micro>         operator "" us(long double);
+constexpr chrono::nanoseconds                           operator "" ns(unsigned long long);
+constexpr chrono::duration<unspecified, nano>          operator "" ns(long double);
+}  // namespace chrono_literals
+}  // namespace literals
+namespace chrono {
+using namespace literals::chrono_literals;
+} // namespace chrono
 }  // namespace std
 ```
 ### Clock requirements <a id="time.clock.req">[[time.clock.req]]</a>
 A clock is a bundle consisting of a `duration`, a `time_point`, and a
+function `now()` to get the current `time_point`. The origin of the
 clock’s `time_point` is referred to as the clock’s *epoch*. A clock
 shall meet the requirements in Table  [[tab:time.clock]].
 In Table  [[tab:time.clock]] `C1` and `C2` denote clock types. `t1` and
 `t2` are values returned by `C1::now()` where the call returning `t1`
   this means, in particular, that operations on these types will not
   throw exceptions.
 - lvalues of the types `TC::rep`, `TC::duration`, and `TC::time_point`
   are swappable ([[swappable.requirements]]),
 - the function `TC::now()` does not throw exceptions, and
+- the type `TC::time_point::clock` meets the `TrivialClock`
+ requirements, recursively.
 ### Time-related traits <a id="time.traits">[[time.traits]]</a>
 #### `treat_as_floating_point` <a id="time.traits.is_fp">[[time.traits.is_fp]]</a>
 #### Specializations of `common_type` <a id="time.traits.specializations">[[time.traits.specializations]]</a>
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
 struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>> {
+  typedef chrono::duration<common_type_t<Rep1, Rep2>, see below> type;
 };
 ```
 The `period` of the `duration` indicated by this specialization of
 `common_type` shall be the greatest common divisor of `Period1` and
 durations may have round-off errors.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
 struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>> {
+  typedef chrono::time_point<Clock, common_type_t<Duration1, Duration2>> type;
 };
 ```
 The common type of two `time_point` types is a `time_point` with the
 same clock as the two types and the common type of their two
 *Remarks:* If `Period::num` is not positive, the program is ill-formed.
 *Requires:* Members of `duration` shall not throw exceptions other than
 those thrown by the indicated operations on their representations.
+*Remarks:* The defaulted copy constructor of duration shall be a
+`constexpr` function if and only if the required initialization of the
+member `rep_` for copy and move, respectively, would satisfy the
+requirements for a `constexpr` function.
 ``` cpp
 duration<long, ratio<60>> d0;       // holds a count of minutes using a long
 duration<long long, milli> d1;      // holds a count of milliseconds using a long long
 duration<double, ratio<1, 30>>  d2; // holds a count with a tick period of $\frac{1}{30}$ of a second
                                     // (30 Hz) using a double
 template <class Rep2, class Period2>
   constexpr duration(const duration<Rep2, Period2>& d);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
+unless no overflow is induced in the conversion and
+`treat_as_floating_point<rep>::value` is `true` or both
 `ratio_divide<Period2, period>::den` is `1` and
 `treat_as_floating_point<Rep2>::value` is `false`. This requirement
 prevents implicit truncation error when converting between
 integral-based `duration` types. Such a construction could easily lead
 to confusion about the value of the `duration`.
 *Returns:* `duration(duration_values<rep>::max())`.
 #### `duration` non-member arithmetic <a id="time.duration.nonmember">[[time.duration.nonmember]]</a>
 In the function descriptions that follow, `CD` represents the return
+type of the function. `CR(A,B)` represents `common_type_t<A, B>`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* CD(CD(lhs).count() + CD(rhs).count()).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* CD(CD(lhs).count() - CD(rhs).count()).
 ``` cpp
 template <class Rep1, class Period, class Rep2>
+  constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator*(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)`.
 *Returns:* CD(CD(d).count() \* s).
 ``` cpp
 template <class Rep1, class Rep2, class Period>
+  constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator*(const Rep1& s, const duration<Rep2, Period>& d);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep1` is implicitly convertible to `CR(Rep1, Rep2)`.
 *Returns:* `d * s`.
 ``` cpp
 template <class Rep1, class Period, class Rep2>
+  constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator/(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
 *Returns:* CD(CD(d).count() / s).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr common_type_t<Rep1, Rep2>
   operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `CD(lhs).count() / CD(rhs).count()`.
 ``` cpp
 template <class Rep1, class Period, class Rep2>
+  constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator%(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
 *Returns:* CD(CD(d).count() % s).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
   operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* CD(CD(lhs).count() % CD(rhs).count()).
 #### `duration` comparisons <a id="time.duration.comparisons">[[time.duration.comparisons]]</a>
 In the function descriptions that follow, `CT` represents
+`common_type_t<A, B>`, where `A` and `B` are the types of the two
 arguments to the function.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 divisions when it is known at compile time that one or more arguments
 is 1. Intermediate computations are carried out in the widest
 representation and only converted to the destination representation at
 the final step.
+#### Suffixes for duration literals <a id="time.duration.literals">[[time.duration.literals]]</a>
+This section describes literal suffixes for constructing duration
+literals. The suffixes `h`, `min`, `s`, `ms`, `us`, `ns` denote duration
+values of the corresponding types `hours`, `minutes`, `seconds`,
+`milliseconds`, `microseconds`, and `nanoseconds` respectively if they
+are applied to integral literals.
+If any of these suffixes are applied to a floating point literal the
+result is a `chrono::duration` literal with an unspecified floating
+point representation.
+If any of these suffixes are applied to an integer literal and the
+resulting `chrono::duration` value cannot be represented in the result
+type because of overflow, the program is ill-formed.
+The following code shows some duration literals.
+``` cpp
+using namespace std::chrono_literals;
+auto constexpr aday=24h;
+auto constexpr lesson=45min;
+auto constexpr halfanhour=0.5h;
+```
+``` cpp
+constexpr chrono::hours                                 operator "" h(unsigned long long hours);
+constexpr chrono::duration<unspecified, ratio<3600,1>> operator "" h(long double hours);
+```
+*Returns:* A `duration` literal representing `hours` hours.
+``` cpp
+constexpr chrono::minutes                             operator "" min(unsigned long long minutes);
+constexpr chrono::duration<unspecified, ratio<60,1>> operator "" min(long double minutes);
+```
+*Returns:* A `duration` literal representing `minutes` minutes.
+``` cpp
+constexpr chrono::seconds                operator "" s(unsigned long long sec);
+constexpr chrono::duration<unspecified> operator "" s(long double sec);
+```
+*Returns:* A `duration` literal representing `sec` seconds.
+The same suffix `s` is used for `basic_string` but there is no conflict,
+since duration suffixes apply to numbers and string literal suffixes
+apply to character array literals.
+``` cpp
+constexpr chrono::milliseconds                  operator "" ms(unsigned long long msec);
+constexpr chrono::duration<unspecified, milli> operator "" ms(long double msec);
+```
+*Returns:* A `duration` literal representing `msec` milliseconds.
+``` cpp
+constexpr chrono::microseconds                  operator "" us(unsigned long long usec);
+constexpr chrono::duration<unspecified, micro> operator "" us(long double usec);
+```
+*Returns:* A `duration` literal representing `usec` microseconds.
+``` cpp
+constexpr chrono::nanoseconds                  operator "" ns(unsigned long long nsec);
+constexpr chrono::duration<unspecified, nano> operator "" ns(long double nsec);
+```
+*Returns:* A `duration` literal representing `nsec` nanoseconds.
 ### Class template `time_point` <a id="time.point">[[time.point]]</a>
 ``` cpp
 template <class Clock, class Duration = typename Clock::duration>
 class time_point {
 private:
   duration d_;  // exposition only
 public:
   // [time.point.cons], construct:
+ constexpr time_point();  // has value epoch
+ constexpr explicit time_point(const duration& d);  // same as time_point() + d
   template <class Duration2>
+    constexpr time_point(const time_point<clock, Duration2>& t);
   // [time.point.observer], observer:
+ constexpr duration time_since_epoch() const;
   // [time.point.arithmetic], arithmetic:
   time_point& operator+=(const duration& d);
   time_point& operator-=(const duration& d);
 ill-formed.
 #### `time_point` constructors <a id="time.point.cons">[[time.point.cons]]</a>
 ``` cpp
+constexpr time_point();
 ```
 *Effects:* Constructs an object of type `time_point`, initializing `d_`
 with `duration::zero()`. Such a `time_point` object represents the
 epoch.
 ``` cpp
+constexpr explicit time_point(const duration& d);
 ```
 *Effects:* Constructs an object of type `time_point`, initializing `d_`
 with `d`. Such a `time_point` object represents the epoch `+ d`.
 ``` cpp
 template <class Duration2>
+ constexpr time_point(const time_point<clock, Duration2>& t);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
 unless `Duration2` is implicitly convertible to `duration`.
 with `t.time_since_epoch()`.
 #### `time_point` observer <a id="time.point.observer">[[time.point.observer]]</a>
 ``` cpp
+constexpr duration time_since_epoch() const;
 ```
 *Returns:* `d_`.
 #### `time_point` arithmetic <a id="time.point.arithmetic">[[time.point.arithmetic]]</a>
 #### `time_point` non-member arithmetic <a id="time.point.nonmember">[[time.point.nonmember]]</a>
 ``` cpp
 template <class Clock, class Duration1, class Rep2, class Period2>
+ constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
   operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
+*Returns:* `CT(lhs.time_since_epoch() + rhs)`, where `CT` is the type of
+the return value.
 ``` cpp
 template <class Rep1, class Period1, class Clock, class Duration2>
+ constexpr time_point<Clock, common_type_t<duration<Rep1, Period1>, Duration2>>
   operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `rhs + lhs`.
 ``` cpp
 template <class Clock, class Duration1, class Rep2, class Period2>
+ constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
   operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `lhs + (-rhs)`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
+ constexpr common_type_t<Duration1, Duration2>
   operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `lhs.time_since_epoch() - rhs.time_since_epoch()`.
 #### `time_point` comparisons <a id="time.point.comparisons">[[time.point.comparisons]]</a>
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
+ constexpr bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `lhs.time_since_epoch() == rhs.time_since_epoch()`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
+ constexpr bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
+ constexpr bool operator<(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `lhs.time_since_epoch() < rhs.time_since_epoch()`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
+ constexpr bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
+ constexpr bool operator>(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
+ constexpr bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 #### `time_point_cast` <a id="time.point.cast">[[time.point.cast]]</a>
 ``` cpp
 template <class ToDuration, class Clock, class Duration>
+ constexpr time_point<Clock, ToDuration>
+  time_point_cast(const time_point<Clock, Duration>& t);
 ```
 *Remarks:* This function shall not participate in overload resolution
 unless `ToDuration` is an instantiation of `duration`.
 public:
   typedef see below                           rep;
   typedef ratio<unspecified, unspecified>   period;
   typedef chrono::duration<rep, period>       duration;
   typedef chrono::time_point<system_clock>    time_point;
+  static constexpr bool is_steady = unspecified;
   static time_point now() noexcept;
   // Map to C API
   static time_t      to_time_t  (const time_point& t) noexcept;
 public:
   typedef unspecified                               rep;
   typedef ratio<unspecified, unspecified>          period;
   typedef chrono::duration<rep, period>              duration;
   typedef chrono::time_point<unspecified, duration>  time_point;
+  static constexpr bool is_steady = true;
   static time_point now() noexcept;
 };
 ```
 public:
   typedef unspecified                               rep;
   typedef ratio<unspecified, unspecified>          period;
   typedef chrono::duration<rep, period>              duration;
   typedef chrono::time_point<unspecified, duration> time_point;
+  static constexpr bool is_steady = unspecified;
   static time_point now() noexcept;
 };
 ```
     pointer allocate(size_type n, const_void_pointer hint);
     void deallocate(pointer p, size_type n);
     size_type max_size() const;
     template <class T, class... Args>
+      void construct(T* p, Args&&... args);
     template <class T1, class T2, class... Args1, class... Args2>
       void construct(pair<T1, T2>* p, piecewise_construct_t,
                      tuple<Args1...> x, tuple<Args2...> y);
     template <class T1, class T2>
       void construct(pair<T1, T2>* p);
 ``` cpp
 scoped_allocator_adaptor();
 ```
+*Effects:* value-initializes the `OuterAlloc` base class and the `inner`
 allocator object.
 ``` cpp
 template <class OuterA2>
   scoped_allocator_adaptor(OuterA2&& outerAlloc,
   `x`.
 - Otherwise, if `uses_allocator<T1, inner_allocator_type>::value` is
   `true` and
   `is_constructible<T1, allocator_arg_t, inner_allocator_type, Args1...>::value`
   is `true`, then `xprime` is
+  `tuple_cat(tuple<allocator_arg_t, inner_allocator_type&>( allocator_arg, inner_allocator()), std::move(x))`.
 - Otherwise, if `uses_allocator<T1, inner_allocator_type>::value` is
   `true` and
   `is_constructible<T1, Args1..., inner_allocator_type>::value` is
   `true`, then `xprime` is
+  `tuple_cat(std::move(x), tuple<inner_allocator_type&>(inner_allocator()))`.
 - Otherwise, the program is ill-formed.
 and constructs a `tuple` object `yprime` from `y` by the following
 rules:
   `y`.
 - Otherwise, if `uses_allocator<T2, inner_allocator_type>::value` is
   `true` and
   `is_constructible<T2, allocator_arg_t, inner_allocator_type, Args2...>::value`
   is `true`, then `yprime` is
+  `tuple_cat(tuple<allocator_arg_t, inner_allocator_type&>( allocator_arg, inner_allocator()), std::move(y))`.
 - Otherwise, if `uses_allocator<T2, inner_allocator_type>::value` is
   `true` and
   `is_constructible<T2, Args2..., inner_allocator_type>::value` is
   `true`, then `yprime` is
+  `tuple_cat(std::move(y), tuple<inner_allocator_type&>(inner_allocator()))`.
 - Otherwise, the program is ill-formed.
 then calls
 *`OUTERMOST_ALLOC_TRAITS`*`(*this)::construct(`*`OUTERMOST`*`(*this), p,`
+`piecewise_construct, std::move(xprime), std::move(yprime))`.
 ``` cpp
 template <class T1, class T2>
   void construct(pair<T1, T2>* p);
 ```
+*Effects:* Equivalent to
 `this->construct(p, piecewise_construct, tuple<>(), tuple<>())`.
 ``` cpp
 template <class T1, class T2, class U, class V>
   void construct(pair<T1, T2>* p, U&& x, V&& y);
 ```
+*Effects:* Equivalent to
 `this->construct(p, piecewise_construct, forward_as_tuple(std::forward<U>(x)), forward_as_tuple(std::forward<V>(y)))`.
 ``` cpp
 template <class T1, class T2, class U, class V>
   void construct(pair<T1, T2>* p, const pair<U, V>& x);
 ```
+*Effects:* Equivalent to
 `this->construct(p, piecewise_construct, forward_as_tuple(x.first), forward_as_tuple(x.second))`.
 ``` cpp
 template <class T1, class T2, class U, class V>
   void construct(pair<T1, T2>* p, pair<U, V>&& x);
 ```
+*Effects:* Equivalent to
 `this->construct(p, piecewise_construct, forward_as_tuple(std::forward<U>(x.first)), forward_as_tuple(std::forward<V>(x.second)))`.
 ``` cpp
 template <class T>
   void destroy(T* p);
     bool operator!=(const type_index& rhs) const noexcept;
     bool operator< (const type_index& rhs) const noexcept;
     bool operator<= (const type_index& rhs) const noexcept;
     bool operator> (const type_index& rhs) const noexcept;
     bool operator>= (const type_index& rhs) const noexcept;
+    size_t hash_code() const noexcept;
+    const char* name() const noexcept;
   private:
     const type_info* target;    // exposition only
     // Note that the use of a pointer here, rather than a reference,
     // means that the default copy/move constructor and assignment
     // operators will be provided and work as expected.
 ```
 *Returns:* `!target->before(*rhs.target)`
 ``` cpp
+size_t hash_code() const noexcept;
 ```
 *Returns:* `target->hash_code()`
 ``` cpp
+const char* name() const noexcept;
 ```
 *Returns:* `target->name()`
 ### Hash support <a id="type.index.hash">[[type.index.hash]]</a>
 ``` cpp
 template <> struct hash<type_index>;
 ```
+The template specialization shall meet the requirements of class
+template `hash` ([[unord.hash]]). For an object `index` of type
 `type_index`, `hash<type_index>()(index)` shall evaluate to the same
 result as `index.hash_code()`.
 <!-- Link reference definitions -->
 [alg.sorting]: algorithms.md#alg.sorting
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.stc.dynamic.safety]: basic.md#basic.stc.dynamic.safety
 [basic.type.qualifier]: basic.md#basic.type.qualifier
 [basic.types]: basic.md#basic.types
 [bitset.cons]: #bitset.cons
 [bitset.hash]: #bitset.hash
 [bitset.members]: #bitset.members
 [bitset.operators]: #bitset.operators
 [bitwise.operations]: #bitwise.operations
 [c.malloc]: #c.malloc
 [c.strings]: strings.md#c.strings
+[class]: class.md#class
 [class.abstract]: class.md#class.abstract
 [class.derived]: class.md#class.derived
 [class.dtor]: special.md#class.dtor
 [class.virtual]: class.md#class.virtual
 [comparisons]: #comparisons
 [forward]: #forward
 [forward.iterators]: iterators.md#forward.iterators
 [func.bind]: #func.bind
 [func.bind.bind]: #func.bind.bind
 [func.bind.isbind]: #func.bind.isbind
+[func.bind.isplace]: #func.bind.isplace
 [func.bind.place]: #func.bind.place
 [func.def]: #func.def
 [func.memfn]: #func.memfn
 [func.require]: #func.require
 [func.wrap]: #func.wrap
 [func.wrap.func.targ]: #func.wrap.func.targ
 [function.objects]: #function.objects
 [hash.requirements]: library.md#hash.requirements
 [input.iterators]: iterators.md#input.iterators
 [intro.multithread]: intro.md#intro.multithread
+[intseq]: #intseq
+[intseq.general]: #intseq.general
+[intseq.intseq]: #intseq.intseq
+[intseq.make]: #intseq.make
 [invalid.argument]: diagnostics.md#invalid.argument
 [iostate.flags]: input.md#iostate.flags
 [istream.formatted]: input.md#istream.formatted
 [lessthancomparable]: #lessthancomparable
 [logical.operations]: #logical.operations
 [time.duration]: #time.duration
 [time.duration.arithmetic]: #time.duration.arithmetic
 [time.duration.cast]: #time.duration.cast
 [time.duration.comparisons]: #time.duration.comparisons
 [time.duration.cons]: #time.duration.cons
+[time.duration.literals]: #time.duration.literals
 [time.duration.nonmember]: #time.duration.nonmember
 [time.duration.observer]: #time.duration.observer
 [time.duration.special]: #time.duration.special
 [time.general]: #time.general
 [time.point]: #time.point
 [type.index.synopsis]: #type.index.synopsis
 [uninitialized.copy]: #uninitialized.copy
 [uninitialized.fill]: #uninitialized.fill
 [uninitialized.fill.n]: #uninitialized.fill.n
 [unique.ptr]: #unique.ptr
+[unique.ptr.create]: #unique.ptr.create
 [unique.ptr.dltr]: #unique.ptr.dltr
 [unique.ptr.dltr.dflt]: #unique.ptr.dltr.dflt
 [unique.ptr.dltr.dflt1]: #unique.ptr.dltr.dflt1
 [unique.ptr.dltr.general]: #unique.ptr.dltr.general
 [unique.ptr.runtime]: #unique.ptr.runtime
 [util.smartptr.weak.spec]: #util.smartptr.weak.spec
 [util.smartptr.weakptr]: #util.smartptr.weakptr
 [utilities]: #utilities
 [utilities.general]: #utilities.general
 [utility]: #utility
+[utility.exchange]: #utility.exchange
 [utility.swap]: #utility.swap
 [^1]: `pointer_safety::preferred` might be returned to indicate that a
     leak detector is running so that the program can avoid spurious leak
     reports.

Diff to HTML by rtfpessoa