[utilities] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpx3u4hpu1/{from.md → to.md} +1901 -3124

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

@@ -8,24 +8,20 @@ standard library. These utilities are summarized in
 [[utilities.summary]].
 **Table: General utilities library summary** <a id="utilities.summary">[utilities.summary]</a>
 | Subclause            |                              | Header         |
-| -------------------- | ----------------------------- | -------------- |
 | [[utility]]          | Utility components           | `<utility>`    |
 | [[pairs]]            | Pairs                        |                |
 | [[tuple]]            | Tuples                       | `<tuple>`      |
 | [[optional]]         | Optional objects             | `<optional>`   |
 | [[variant]]          | Variants                     | `<variant>`    |
 | [[any]]              | Storage for any type         | `<any>`        |
 | [[expected]]         | Expected objects             | `<expected>`   |
 | [[bitset]]           | Fixed-size sequences of bits | `<bitset>`     |
 | [[function.objects]] | Function objects             | `<functional>` |
-| [[type.index]]       | Type indexes                  | `<typeindex>`  |
-| [[execpol]]          | Execution policies            | `<execution>`  |
-| [[charconv]]         | Primitive numeric conversions | `<charconv>`   |
-| [[format]]           | Formatting                    | `<format>`     |
 | [[bit]]              | Bit manipulation             | `<bit>`        |
 ## Utility components <a id="utility">[[utility]]</a>
@@ -54,11 +50,11 @@ namespace std {
   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, class U>
- [[nodiscard]] constexpr auto forward_like(U&& x) noexcept -> see below;
   template<class T>
     constexpr remove_reference_t<T>&& move(T&&) noexcept;
   template<class T>
     constexpr conditional_t<
         !is_nothrow_move_constructible_v<T> && is_copy_constructible_v<T>, const T&, T&&>
@@ -94,12 +90,13 @@ namespace std {
   // [utility.underlying], to_underlying
   template<class T>
     constexpr underlying_type_t<T> to_underlying(T value) noexcept;
-  // [utility.unreachable], unreachable
   [[noreturn]] void unreachable();
   // [intseq], compile-time integer sequences%
 %
 %
@@ -212,10 +209,33 @@ namespace std {
   template<size_t I>
     struct in_place_index_t {
       explicit in_place_index_t() = default;
     };
   template<size_t I> constexpr in_place_index_t<I> in_place_index{};
 }
 ```
 ### `swap` <a id="utility.swap">[[utility.swap]]</a>
@@ -316,11 +336,11 @@ constructor as an lvalue. In both cases, `A2` is deduced as `double`, so
 — *end example*]
 ``` cpp
 template<class T, class U>
- [[nodiscard]] constexpr auto forward_like(U&& x) noexcept -> see below;
 ```
 *Mandates:* `T` is a referenceable type [[defns.referenceable]].
 - Let *`COPY_CONST`*`(A, B)` be `const B` if `A` is a const type,
@@ -535,11 +555,11 @@ template<class T>
   constexpr underlying_type_t<T> to_underlying(T value) noexcept;
 ```
 *Returns:* `static_cast<underlying_type_t<T>>(value)`.
-### Function `unreachable` <a id="utility.unreachable">[[utility.unreachable]]</a>
 ``` cpp
 [[noreturn]] void unreachable();
 ```
@@ -564,13 +584,19 @@ int a = f(1);           // OK, a has value 1
 int b = f(3);           // undefined behavior
 ```
 — *end example*]
 ## Pairs <a id="pairs">[[pairs]]</a>
-### In general <a id="pairs.general">[[pairs.general]]</a>
 The library provides a template for heterogeneous pairs of values. The
 library also provides a matching function template to simplify their
 construction and several templates that provide access to `pair` objects
 as if they were `tuple` objects (see  [[tuple.helper]] and
@@ -632,28 +658,28 @@ namespace std {
   template<class T1, class T2>
     pair(T1, T2) -> pair<T1, T2>;
 }
 ```
-Constructors and member functions of `pair` do 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` is a
 constexpr function if and only if all required element-wise
 initializations for move and copy, respectively, would be
 constexpr-suitable [[dcl.constexpr]].
 If
 `(is_trivially_destructible_v<T1> && is_trivially_destructible_v<T2>)`
 is `true`, then the destructor of `pair` is trivial.
-`pair<T, U>` is a structural type [[temp.param]] if `T` and `U` are both
-structural types. Two values `p1` and `p2` of type `pair<T, U>` are
-template-argument-equivalent [[temp.type]] if and only if `p1.first` and
-`p2.first` are template-argument-equivalent and `p1.second` and
-`p2.second` are template-argument-equivalent.
 ``` cpp
 constexpr explicit(see below) pair();
 ```
@@ -829,12 +855,12 @@ constexpr pair& operator=(pair&& p) noexcept(see below);
 *Constraints:*
 - `is_move_assignable_v<T1>` is `true` and
 - `is_move_assignable_v<T2>` is `true`.
-*Effects:* Assigns to `first` with `std::forward<T1>(p.first)` and to
-`second` with `std::forward<T2>(p.second)`.
 *Returns:* `*this`.
 *Remarks:* The exception specification is equivalent to:
@@ -863,13 +889,12 @@ template<class U1, class U2> constexpr pair& operator=(pair<U1, U2>&& p);
 *Constraints:*
 - `is_assignable_v<T1&, U1>` is `true` and
 - `is_assignable_v<T2&, U2>` is `true`.
-*Effects:* Assigns to `first` with `std::forward<U1>(p.first)` and to
-`second` with
-`std::forward<U2>(p.second)`.
 *Returns:* `*this`.
 ``` cpp
 template<pair-like P> constexpr pair& operator=(P&& p);
@@ -950,12 +975,13 @@ constexpr void swap(const pair& p) const noexcept(see below);
 ``` cpp
 template<class T1, class T2, class U1, class U2>
   constexpr bool operator==(const pair<T1, T2>& x, const pair<U1, U2>& y);
 ```
-*Preconditions:* Each of `decltype(x.first == y.first)` and
-`decltype(x.second == y.second)` models `boolean-testable`.
 *Returns:* `x.first == y.first && x.second == y.second`.
 ``` cpp
 template<class T1, class T2, class U1, class U2>
@@ -1029,11 +1055,11 @@ template<size_t I, class T1, class T2>
   };
 ```
 *Mandates:* `I` < 2.
-*Type:* The type `T1` if `I` is 0, otherwise 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>
@@ -1097,20 +1123,24 @@ the first argument, immediately followed by two `tuple` [[tuple]]
 arguments used for piecewise construction of the elements of the `pair`
 object.
 ## Tuples <a id="tuple">[[tuple]]</a>
-### In general <a id="tuple.general">[[tuple.general]]</a>
 Subclause  [[tuple]] describes the tuple library that provides a tuple
 type as the class template `tuple` that can be instantiated with any
 number of arguments. Each template argument specifies the type of an
 element in the `tuple`. Consequently, tuples are heterogeneous,
 fixed-size collections of values. An instantiation of `tuple` with two
 arguments is similar to an instantiation of `pair` with the same two
 arguments. See  [[pairs]].
 ### Header `<tuple>` synopsis <a id="tuple.syn">[[tuple.syn]]</a>
 ``` cpp
 // all freestanding
 #include <compare>              // see [compare.syn]
@@ -1132,13 +1162,18 @@ namespace std {
            template<class> class TQual, template<class> class UQual>
     struct basic_common_reference<TTuple, UTuple, TQual, UQual>;
   template<exposition onlyconceptnc{tuple-like} TTuple, exposition onlyconceptnc{tuple-like} UTuple>
     struct common_type<TTuple, UTuple>;
   // [tuple.creation], tuple creation functions
-  inline constexpr unspecified ignore;
   template<class... TTypes>
     constexpr tuple<unwrap_ref_decay_t<TTypes>...> make_tuple(TTypes&&...);
   template<class... TTypes>
     constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&...) noexcept;
@@ -1149,11 +1184,12 @@ namespace std {
   template<exposition onlyconceptnc{tuple-like}... Tuples>
     constexpr tuple<CTypes...> tuple_cat(Tuples&&...);
   // [tuple.apply], calling a function with a tuple of arguments
   template<class F, exposition onlyconceptnc{tuple-like} Tuple>
-    constexpr decltype(auto) apply(F&& f, Tuple&& t) noexcept(see below);
   template<class T, exposition onlyconceptnc{tuple-like} Tuple>
     constexpr T make_from_tuple(Tuple&& t);
   // [tuple.helper], tuple helper classes
@@ -1167,11 +1203,11 @@ namespace std {
   template<size_t I, class... Types>
     struct tuple_element<I, tuple<Types...>>;
   template<size_t I, class T>
-    using tuple_element_t = typename tuple_element<I, T>::type;
   // [tuple.elem], element access
   template<size_t I, class... Types>
     constexpr tuple_element_t<I, tuple<Types...>>& get(tuple<Types...>&) noexcept;
   template<size_t I, class... Types>
@@ -1222,15 +1258,17 @@ namespace std {
 template<class T>
   concept tuple-like = see belownc;           // exposition only
 ```
 A type `T` models and satisfies the exposition-only concept `tuple-like`
-if `remove_cvref_t<T>` is a specialization of `array`, `pair`, `tuple`,
-or `ranges::subrange`.
 ### Class template `tuple` <a id="tuple.tuple">[[tuple.tuple]]</a>
 ``` cpp
 namespace std {
   template<class... Types>
   class tuple {
   public:
@@ -1352,10 +1390,13 @@ namespace std {
   template<class Alloc, class... UTypes>
     tuple(allocator_arg_t, Alloc, tuple<UTypes...>) -> tuple<UTypes...>;
 }
 ```
 #### Construction <a id="tuple.cnstr">[[tuple.cnstr]]</a>
 In the descriptions that follow, let i be in the range \[`0`,
 `sizeof...(Types)`) in order, `Tᵢ` be the iᵗʰ type in `Types`, and `Uᵢ`
 be the iᵗʰ type in a template parameter pack named `UTypes`, where
@@ -1466,11 +1507,11 @@ template<class... UTypes> constexpr explicit(see below) tuple(tuple<UTypes...>&
 template<class... UTypes> constexpr explicit(see below) tuple(const tuple<UTypes...>& u);
 template<class... UTypes> constexpr explicit(see below) tuple(tuple<UTypes...>&& u);
 template<class... UTypes> constexpr explicit(see below) tuple(const tuple<UTypes...>&& u);
 ```
-Let `I` be the pack `0, 1, ..., (sizeof...(Types) - 1)`. Let
 *`FWD`*`(u)` be `static_cast<decltype(u)>(u)`.
 *Constraints:*
 - `sizeof...(Types)` equals `sizeof...(UTypes)`, and
@@ -1537,21 +1578,21 @@ is `true`.
 ``` cpp
 template<tuple-like UTuple>
   constexpr explicit(see below) tuple(UTuple&& u);
 ```
-Let `I` be the pack `0, 1, …, (sizeof...(Types) - 1)`.
 *Constraints:*
 - `different-from<UTuple, tuple>` [[range.utility.helpers]] is `true`,
 - `remove_cvref_t<UTuple>` is not a specialization of
   `ranges::subrange`,
 - `sizeof...(Types)` equals `tuple_size_v<remove_cvref_t<UTuple>>`,
 - `(is_constructible_v<Types, decltype(get<I>(std::forward<UTuple>(u)))> && ...)`
   is `true`, and
-- either `sizeof...(Types)` is not `1`, or (when `Types...` expands to
   `T`) `is_convertible_v<UTuple, T>` and `is_constructible_v<T, UTuple>`
   are both `false`.
 *Effects:* For all i, initializes the iᵗʰ element of `*this` with
 `get<`i`>(std::forward<UTuple>(u))`.
@@ -1560,10 +1601,19 @@ Let `I` be the pack `0, 1, …, (sizeof...(Types) - 1)`.
 ``` cpp
 !(is_convertible_v<decltype(get<I>(std::forward<UTuple>(u))), Types> && ...)
 ```
 ``` cpp
 template<class Alloc>
   constexpr explicit(see below)
     tuple(allocator_arg_t, const Alloc& a);
 template<class Alloc>
@@ -1802,11 +1852,11 @@ template<tuple-like UTuple>
 *Constraints:*
 - `different-from<UTuple, tuple>` [[range.utility.helpers]] is `true`,
 - `remove_cvref_t<UTuple>` is not a specialization of
   `ranges::subrange`,
-- `sizeof...(Types)` equals `tuple_size_v<remove_cvref_t<UTuple>>`, and,
 - `is_assignable_v<``Tᵢ``&, decltype(get<`i`>(std::forward<UTuple>(u)))>`
   is `true` for all i.
 *Effects:* For all i, assigns `get<`i`>(std::forward<UTuple>(u))` to
 `get<`i`>(*this)`.
@@ -1821,11 +1871,11 @@ template<tuple-like UTuple>
 *Constraints:*
 - `different-from<UTuple, tuple>` [[range.utility.helpers]] is `true`,
 - `remove_cvref_t<UTuple>` is not a specialization of
   `ranges::subrange`,
-- `sizeof...(Types)` equals `tuple_size_v<remove_cvref_t<UTuple>>`, and,
 - `is_assignable_v<const ``Tᵢ``&, decltype(get<`i`>(std::forward<UTuple>(u)))>`
   is `true` for all i.
 *Effects:* For all i, assigns `get<`i`>(std::forward<UTuple>(u))` to
 `get<`i`>(*this)`.
@@ -1848,11 +1898,11 @@ Let i be in the range \[`0`, `sizeof...(Types)`) in order.
   `true`.
 *Preconditions:* For all i, `get<`i`>(*this)` is swappable
 with [[swappable.requirements]] `get<`i`>(rhs)`.
-*Effects:* For each i, calls `swap` for `get<`i`>(*this)` with
 `get<`i`>(rhs)`.
 *Throws:* Nothing unless one of the element-wise `swap` calls throws an
 exception.
@@ -1900,13 +1950,11 @@ variable).
 ``` cpp
 template<class... TTypes>
   constexpr tuple<TTypes&...> tie(TTypes&... t) noexcept;
 ```
-*Returns:* `tuple<TTypes&...>(t...)`. When an argument in `t` is
-`ignore`, assigning any value to the corresponding tuple element has no
-effect.
 [*Example 2*:
 `tie` functions allow one to create tuples that unpack tuples into
 variables. `ignore` can be used for elements that are not needed:
@@ -1948,14 +1996,15 @@ elems₀`...`, …, elemsₙ₋₁`...`.
 ### Calling a function with a `tuple` of arguments <a id="tuple.apply">[[tuple.apply]]</a>
 ``` cpp
 template<class F, tuple-like Tuple>
-  constexpr decltype(auto) apply(F&& f, Tuple&& t) noexcept(see below);
 ```
-*Effects:* Given the exposition-only function:
 ``` cpp
 namespace std {
   template<class F, tuple-like Tuple, size_t... I>
   constexpr decltype(auto) apply-impl(F&& f, Tuple&& t, index_sequence<I...>) {
@@ -1970,28 +2019,20 @@ Equivalent to:
 ``` cpp
 return apply-impl(std::forward<F>(f), std::forward<Tuple>(t),
                   make_index_sequence<tuple_size_v<remove_reference_t<Tuple>>>{});
 ```
-*Remarks:* Let `I` be the pack
-`0, 1, ..., (tuple_size_v<remove_reference_t<Tuple>> - 1)`. The
-exception specification is equivalent to:
-``` cpp
-noexcept(invoke(std::forward<F>(f), get<I>(std::forward<Tuple>(t))...))
-```
 ``` cpp
 template<class T, tuple-like Tuple>
   constexpr T make_from_tuple(Tuple&& t);
 ```
 *Mandates:* If `tuple_size_v<remove_reference_t<Tuple>>` is 1, then
 `reference_constructs_from_temporary_v<T, decltype(get<0>(declval<Tuple>()))>`
 is `false`.
-*Effects:* Given the exposition-only function:
 ``` cpp
 namespace std {
   template<class T, tuple-like Tuple, size_t... I>
     requires is_constructible_v<T, decltype(get<I>(declval<Tuple>()))...>
@@ -2017,17 +2058,17 @@ list. — *end note*]
 ``` cpp
 template<class T> struct tuple_size;
 ```
-All specializations of `tuple_size` meet the *Cpp17UnaryTypeTrait*
-requirements [[meta.rqmts]] with a base characteristic of
-`integral_constant<size_t, N>` for some `N`.
 ``` cpp
 template<class... Types>
-  struct tuple_size<tuple<Types...>> : public integral_constant<size_t, sizeof...(Types)> { };
 ```
 ``` cpp
 template<size_t I, class... Types>
   struct tuple_element<I, tuple<Types...>> {
@@ -2035,12 +2076,12 @@ template<size_t I, class... Types>
   };
 ```
 *Mandates:* `I` < `sizeof...(Types)`.
-*Type:* `TI` is the type of the `I`ᵗʰ element of `Types`, where indexing
-is zero-based.
 ``` cpp
 template<class T> struct tuple_size<const T>;
 ```
@@ -2075,11 +2116,11 @@ template<size_t I, class T> struct tuple_element<I, const T>;
 ```
 Let `TE` denote `tuple_element_t<I, T>` of the cv-unqualified type `T`.
 Then each specialization of the template meets the
 *Cpp17TransformationTrait* requirements [[meta.rqmts]] with a member
-typedef `type` that names the type `add_const_t<TE>`.
 In addition to being available via inclusion of the `<tuple>` header,
 the template is available when any of the headers `<array>`, `<ranges>`,
 or `<utility>` are included.
@@ -2089,32 +2130,34 @@ or `<utility>` are included.
 template<size_t I, class... Types>
   constexpr tuple_element_t<I, tuple<Types...>>&
     get(tuple<Types...>& t) noexcept;
 template<size_t I, class... Types>
   constexpr tuple_element_t<I, tuple<Types...>>&&
-    get(tuple<Types...>&& t) noexcept;        // Note A
 template<size_t I, class... Types>
   constexpr const tuple_element_t<I, tuple<Types...>>&
-    get(const tuple<Types...>& t) noexcept;   // Note B
 template<size_t I, class... Types>
   constexpr const tuple_element_t<I, tuple<Types...>>&& get(const tuple<Types...>&& t) noexcept;
 ```
 *Mandates:* `I` < `sizeof...(Types)`.
 *Returns:* A reference to the `I`ᵗʰ element of `t`, where indexing is
 zero-based.
-[*Note 1*: \[Note A\]If a type `T` in `Types` is some reference type
-`X&`, the return type is `X&`, not `X&&`. However, if the element type
-is a non-reference type `T`, the return type is `T&&`. — *end note*]
-[*Note 2*: \[Note B\]Constness is shallow. If a type `T` in `Types` is
-some reference type `X&`, the return type is `X&`, not `const X&`.
-However, if the element type is a non-reference type `T`, the return
-type is `const T&`. This is consistent with how constness is defined to
-work for non-static data members of reference type. — *end note*]
 ``` cpp
 template<class T, class... Types>
   constexpr T& get(tuple<Types...>& t) noexcept;
 template<class T, class... Types>
@@ -2155,16 +2198,14 @@ template<class... TTypes, tuple-like UTuple>
   constexpr bool operator==(const tuple<TTypes...>& t, const UTuple& u);
 ```
 For the first overload let `UTuple` be `tuple<UTypes...>`.
-*Mandates:* For all `i`, where 0 ≤ `i` < `sizeof...(TTypes)`,
-`get<i>(t) == get<i>(u)` is a valid expression. `sizeof...(TTypes)`
-equals `tuple_size_v<UTuple>`.
-*Preconditions:* For all `i`, `decltype(get<i>(t) == get<i>(u))` models
-`boolean-testable`.
 *Returns:* `true` if `get<i>(t) == get<i>(u)` for all `i`, otherwise
 `false`.
 [*Note 1*: If `sizeof...(TTypes)` equals zero, returns
@@ -2208,11 +2249,11 @@ lookup [[basic.lookup.argdep]] only.
 [*Note 1*: The above definition does not require `tₜₐᵢₗ` (or `uₜₐᵢₗ`)
 to be constructed. It might not even be possible, as `t` and `u` are not
 required to be copy constructible. Also, all comparison operator
 functions are short circuited; they do not perform element accesses
-beyond what is required to determine the result of the
 comparison. — *end note*]
 ### `common_reference` related specializations <a id="tuple.common.ref">[[tuple.common.ref]]</a>
 In the descriptions that follow:
@@ -2240,11 +2281,11 @@ struct basic_common_reference<TTuple, UTuple, TQual, UQual> {
 - `is_same_v<UTuple, decay_t<UTuple>>` is `true`.
 - `tuple_size_v<TTuple>` equals `tuple_size_v<UTuple>`.
 - `tuple<common_reference_t<TQual<TTypes>, UQual<UTypes>>...>` denotes a
   type.
-The member *typedef-name* `type` denotes the type
 `tuple<common_reference_t<TQual<TTypes>, UQual<UTypes>>...>`.
 ``` cpp
 template<tuple-like TTuple, tuple-like UTuple>
 struct common_type<TTuple, UTuple> {
@@ -2259,11 +2300,11 @@ struct common_type<TTuple, UTuple> {
 - `is_same_v<TTuple, decay_t<TTuple>>` is `true`.
 - `is_same_v<UTuple, decay_t<UTuple>>` is `true`.
 - `tuple_size_v<TTuple>` equals `tuple_size_v<UTuple>`.
 - `tuple<common_type_t<TTypes, UTypes>...>` denotes a type.
-The member *typedef-name* `type` denotes the type
 `tuple<common_type_t<TTypes, UTypes>...>`.
 ### Tuple traits <a id="tuple.traits">[[tuple.traits]]</a>
 ``` cpp
@@ -2301,11 +2342,11 @@ template<class... Types>
 noexcept(x.swap(y))
 ```
 ## Optional objects <a id="optional">[[optional]]</a>
-### In general <a id="optional.general">[[optional.general]]</a>
 Subclause  [[optional]] describes class template `optional` that
 represents optional objects. An *optional object* is an object that
 contains the storage for another object and manages the lifetime of this
 contained object, if any. The contained object may be initialized after
@@ -2314,16 +2355,28 @@ the optional object has been destroyed. The initialization state of the
 contained object is tracked by the optional object.
 ### Header `<optional>` synopsis <a id="optional.syn">[[optional.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
 namespace std {
   // [optional.optional], class template optional
   template<class T>
-    class optional;
   template<class T>
     concept is-derived-from-optional = requires(const T& t) {   // exposition only
       []<class U>(const optional<U>&){ }(t);
     };
@@ -2378,11 +2431,11 @@ namespace std {
   // [optional.specalg], specialized algorithms
   template<class T>
     constexpr void swap(optional<T>&, optional<T>&) noexcept(see below);
   template<class T>
-    constexpr optional<see below> make_optional(T&&);
   template<class T, class... Args>
     constexpr optional<T> make_optional(Args&&... args);
   template<class T, class U, class... Args>
     constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args);
@@ -2400,21 +2453,23 @@ namespace std {
 namespace std {
   template<class T>
   class optional {
   public:
     using value_type     = T;
     // [optional.ctor], constructors
     constexpr optional() noexcept;
     constexpr optional(nullopt_t) noexcept;
     constexpr optional(const optional&);
     constexpr optional(optional&&) noexcept(see below);
     template<class... Args>
       constexpr explicit optional(in_place_t, Args&&...);
     template<class U, class... Args>
       constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
-    template<class U = T>
       constexpr explicit(see below) optional(U&&);
     template<class U>
       constexpr explicit(see below) optional(const optional<U>&);
     template<class U>
       constexpr explicit(see below) optional(optional<U>&&);
@@ -2424,34 +2479,40 @@ namespace std {
     // [optional.assign], assignment
     constexpr optional& operator=(nullopt_t) noexcept;
     constexpr optional& operator=(const optional&);
     constexpr optional& operator=(optional&&) noexcept(see below);
-    template<class U = T> constexpr optional& operator=(U&&);
     template<class U> constexpr optional& operator=(const optional<U>&);
     template<class U> constexpr optional& operator=(optional<U>&&);
     template<class... Args> constexpr T& emplace(Args&&...);
     template<class U, class... Args> constexpr T& emplace(initializer_list<U>, Args&&...);
     // [optional.swap], swap
     constexpr void swap(optional&) noexcept(see below);
     // [optional.observe], observers
     constexpr const T* operator->() const noexcept;
     constexpr T* operator->() noexcept;
     constexpr const T& operator*() const & noexcept;
     constexpr T& operator*() & noexcept;
     constexpr T&& operator*() && noexcept;
     constexpr const T&& operator*() const && noexcept;
     constexpr explicit operator bool() const noexcept;
     constexpr bool has_value() const noexcept;
-    constexpr const T& value() const &;
-    constexpr T& value() &;
-    constexpr T&& value() &&;
-    constexpr const T&& value() const &&;
-    template<class U> constexpr T value_or(U&&) const &;
-    template<class U> constexpr T value_or(U&&) &&;
     // [optional.monadic], monadic operations
     template<class F> constexpr auto and_then(F&& f) &;
     template<class F> constexpr auto and_then(F&& f) &&;
     template<class F> constexpr auto and_then(F&& f) const &;
@@ -2473,25 +2534,29 @@ namespace std {
   template<class T>
     optional(T) -> optional<T>;
 }
 ```
-Any instance of `optional<T>` at any given time either contains a value
-or does not contain a value. When an instance of `optional<T>` *contains
-a value*, it means that an object of type `T`, referred to as the
-optional object’s *contained value*, is allocated within the storage of
-the optional object. Implementations are not permitted to use additional
-storage, such as dynamic memory, to allocate its contained value. When
-an object of type `optional<T>` is contextually converted to `bool`, the
-conversion returns `true` if the object contains a value; otherwise the
-conversion returns `false`.
-When an `optional<T>` object contains a value, member `val` points to
-the contained value.
-`T` shall be a type other than cv `in_place_t` or cv `nullopt_t` that
-meets the *Cpp17Destructible* requirements ([[cpp17.destructible]]).
 #### Constructors <a id="optional.ctor">[[optional.ctor]]</a>
 The exposition-only variable template *`converts-from-any-cvref`* is
 used by some constructors for `optional`.
@@ -2536,11 +2601,11 @@ constexpr optional(optional&& rhs) noexcept(see below);
 ```
 *Constraints:* `is_move_constructible_v<T>` is `true`.
 *Effects:* If `rhs` contains a value, direct-non-list-initializes the
-contained value with `std::move(*rhs)`. `rhs.has_value()` is unchanged.
 *Ensures:* `rhs.has_value() == this->has_value()`.
 *Throws:* Any exception thrown by the selected constructor of `T`.
@@ -2582,11 +2647,11 @@ template<class U, class... Args>
 *Remarks:* If `T`’s constructor selected for the initialization is a
 constexpr constructor, this constructor is a constexpr constructor.
 ``` cpp
-template<class U = T> constexpr explicit(see below) optional(U&& v);
 ```
 *Constraints:*
 - `is_constructible_v<T, U>` is `true`,
@@ -2642,11 +2707,11 @@ template<class U> constexpr explicit(see below) optional(optional<U>&& rhs);
 - `is_constructible_v<T, U>` is `true`, and
 - if `T` is not cv `bool`, *`converts-from-any-cvref`*`<T, optional<U>>`
   is `false`.
 *Effects:* If `rhs` contains a value, direct-non-list-initializes the
-contained value with `std::move(*rhs)`. `rhs.has_value()` is unchanged.
 *Ensures:* `rhs.has_value() == this->has_value()`.
 *Throws:* Any exception thrown by the selected constructor of `T`.
@@ -2726,11 +2791,11 @@ constexpr optional& operator=(optional&& rhs) noexcept(see below);
 **Table: `optional::operator=(optional&&)` effects** <a id="optional.assign.move">[optional.assign.move]</a>
 |                                | `*this` contains a value                               | `*this` does not contain a value                                       |
 | ------------------------------ | ------------------------------------------------------ | ---------------------------------------------------------------------- |
-| `rhs` contains a value         | assigns `std::move(*rhs)` to the contained value       | direct-non-list-initializes the contained value with `std::move(*rhs)` |
 | `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                              |
 *Ensures:* `rhs.has_value() == this->has_value()`.
@@ -2752,17 +2817,19 @@ guarantee of `T`’s move assignment. If
 `is_trivially_move_constructible_v<T> &&`
 `is_trivially_move_assignable_v<T> &&` `is_trivially_destructible_v<T>`
 is `true`, this assignment operator is trivial.
 ``` cpp
-template<class U = T> constexpr optional<T>& operator=(U&& v);
 ```
-*Constraints:* `is_same_v<remove_cvref_t<U>, optional>` is `false`,
-`conjunction_v<is_scalar<T>, is_same<T, decay_t<U>>>` is `false`,
-`is_constructible_v<T, U>` is `true`, and `is_assignable_v<T&, U>` is
-`true`.
 *Effects:* If `*this` contains a value, assigns `std::forward<U>(v)` to
 the contained value; otherwise direct-non-list-initializes the contained
 value with `std::forward<U>(v)`.
@@ -2832,11 +2899,11 @@ expression `rhs.has_value()` remains unchanged.
 **Table: `optional::operator=(optional<U>&&)` effects** <a id="optional.assign.move.templ">[optional.assign.move.templ]</a>
 |                                | `*this` contains a value                               | `*this` does not contain a value                                       |
 | ------------------------------ | ------------------------------------------------------ | ---------------------------------------------------------------------- |
-| `rhs` contains a value         | assigns `std::move(*rhs)` to the contained value       | direct-non-list-initializes the contained value with `std::move(*rhs)` |
 | `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                              |
 *Ensures:* `rhs.has_value() == this->has_value()`.
@@ -2925,40 +2992,75 @@ exception is thrown during the call to function `swap`, the state of
 `*val` and `*rhs.val` is determined by the exception safety guarantee of
 `swap` for lvalues of `T`. If an exception is thrown during the call to
 `T`’s move constructor, the state of `*val` and `*rhs.val` is determined
 by the exception safety guarantee of `T`’s move constructor.
 #### Observers <a id="optional.observe">[[optional.observe]]</a>
 ``` cpp
 constexpr const T* operator->() const noexcept;
 constexpr T* operator->() noexcept;
 ```
-*Preconditions:* `*this` contains a value.
 *Returns:* `val`.
 *Remarks:* These functions are constexpr functions.
 ``` cpp
 constexpr const T& operator*() const & noexcept;
 constexpr T& operator*() & noexcept;
 ```
-*Preconditions:* `*this` contains a value.
 *Returns:* `*val`.
 *Remarks:* These functions are constexpr functions.
 ``` cpp
 constexpr T&& operator*() && noexcept;
 constexpr const T&& operator*() const && noexcept;
 ```
-*Preconditions:* `*this` contains a value.
 *Effects:* Equivalent to: `return std::move(*val);`
 ``` cpp
 constexpr explicit operator bool() const noexcept;
@@ -2997,11 +3099,11 @@ constexpr const T&& value() const &&;
 ``` cpp
 return has_value() ? std::move(*val) : throw bad_optional_access();
 ```
 ``` cpp
-template<class U> constexpr T value_or(U&& v) const &;
 ```
 *Mandates:* `is_copy_constructible_v<T> && is_convertible_v<U&&, T>` is
 `true`.
@@ -3010,11 +3112,11 @@ template<class U> constexpr T value_or(U&& v) const &;
 ``` cpp
 return has_value() ? **this : static_cast<T>(std::forward<U>(v));
 ```
 ``` cpp
-template<class U> constexpr T value_or(U&& v) &&;
 ```
 *Mandates:* `is_move_constructible_v<T> && is_convertible_v<U&&, T>` is
 `true`.
@@ -3029,96 +3131,96 @@ return has_value() ? std::move(**this) : static_cast<T>(std::forward<U>(v));
 ``` cpp
 template<class F> constexpr auto and_then(F&& f) &;
 template<class F> constexpr auto and_then(F&& f) const &;
 ```
-Let `U` be `invoke_result_t<F, decltype(value())>`.
 *Mandates:* `remove_cvref_t<U>` is a specialization of `optional`.
 *Effects:* Equivalent to:
 ``` cpp
 if (*this) {
-  return invoke(std::forward<F>(f), value());
 } else {
   return remove_cvref_t<U>();
 }
 ```
 ``` cpp
 template<class F> constexpr auto and_then(F&& f) &&;
 template<class F> constexpr auto and_then(F&& f) const &&;
 ```
-Let `U` be `invoke_result_t<F, decltype(std::move(value()))>`.
 *Mandates:* `remove_cvref_t<U>` is a specialization of `optional`.
 *Effects:* Equivalent to:
 ``` cpp
 if (*this) {
-  return invoke(std::forward<F>(f), std::move(value()));
 } else {
   return remove_cvref_t<U>();
 }
 ```
 ``` cpp
 template<class F> constexpr auto transform(F&& f) &;
 template<class F> constexpr auto transform(F&& f) const &;
 ```
-Let `U` be `remove_cv_t<invoke_result_t<F, decltype(value())>>`.
-*Mandates:* `U` is a non-array object type other than `in_place_t` or
-`nullopt_t`. The declaration
 ``` cpp
-U u(invoke(std::forward<F>(f), value()));
 ```
 is well-formed for some invented variable `u`.
 [*Note 1*: There is no requirement that `U` is
 movable [[dcl.init.general]]. — *end note*]
 *Returns:* If `*this` contains a value, an `optional<U>` object whose
 contained value is direct-non-list-initialized with
-`invoke(std::forward<F>(f), value())`; otherwise, `optional<U>()`.
 ``` cpp
 template<class F> constexpr auto transform(F&& f) &&;
 template<class F> constexpr auto transform(F&& f) const &&;
 ```
 Let `U` be
-`remove_cv_t<invoke_result_t<F, decltype(std::move(value()))>>`.
-*Mandates:* `U` is a non-array object type other than `in_place_t` or
-`nullopt_t`. The declaration
 ``` cpp
-U u(invoke(std::forward<F>(f), std::move(value())));
 ```
 is well-formed for some invented variable `u`.
 [*Note 2*: There is no requirement that `U` is
 movable [[dcl.init.general]]. — *end note*]
 *Returns:* If `*this` contains a value, an `optional<U>` object whose
 contained value is direct-non-list-initialized with
-`invoke(std::forward<F>(f), std::move(value()))`; otherwise,
 `optional<U>()`.
 ``` cpp
 template<class F> constexpr optional or_else(F&& f) const &;
 ```
-*Constraints:* `F` models `invocable<>` and `T` models
 `copy_constructible`.
 *Mandates:* `is_same_v<remove_cvref_t<invoke_result_t<F>>, optional>` is
 `true`.
@@ -3134,11 +3236,11 @@ if (*this) {
 ``` cpp
 template<class F> constexpr optional or_else(F&& f) &&;
 ```
-*Constraints:* `F` models `invocable<>` and `T` models
 `move_constructible`.
 *Mandates:* `is_same_v<remove_cvref_t<invoke_result_t<F>>, optional>` is
 `true`.
@@ -3161,10 +3263,432 @@ constexpr void reset() noexcept;
 *Effects:* If `*this` contains a value, calls `val->T::T̃()` to destroy
 the contained value; otherwise no effect.
 *Ensures:* `*this` does not contain a value.
 ### No-value state indicator <a id="optional.nullopt">[[optional.nullopt]]</a>
 ``` cpp
 struct nullopt_t{see below};
 inline constexpr nullopt_t nullopt(unspecified);
@@ -3184,33 +3708,34 @@ initializer-list constructor, and shall not be an aggregate.
 ``` cpp
 namespace std {
   class bad_optional_access : public exception {
   public:
     // see [exception] for the specification of the special member functions
-    const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_optional_access` defines the type of objects thrown as
 exceptions to report the situation where an attempt is made to access
 the value of an optional object that does not contain a value.
 ``` cpp
-const char* what() const noexcept override;
 ```
-*Returns:* An *implementation-defined* NTBS.
 ### Relational operators <a id="optional.relops">[[optional.relops]]</a>
 ``` cpp
 template<class T, class U> constexpr bool operator==(const optional<T>& x, const optional<U>& y);
 ```
-*Mandates:* The expression `*x == *y` is well-formed and its result is
-convertible to `bool`.
 [*Note 1*: `T` need not be *Cpp17EqualityComparable*. — *end note*]
 *Returns:* If `x.has_value() != y.has_value()`, `false`; otherwise if
 `x.has_value() == false`, `true`; otherwise `*x == *y`.
@@ -3220,12 +3745,12 @@ convertible to `bool`.
 ``` cpp
 template<class T, class U> constexpr bool operator!=(const optional<T>& x, const optional<U>& y);
 ```
-*Mandates:* The expression `*x != *y` is well-formed and its result is
-convertible to `bool`.
 *Returns:* If `x.has_value() != y.has_value()`, `true`; otherwise, if
 `x.has_value() == false`, `false`; otherwise `*x != *y`.
 *Remarks:* Specializations of this function template for which
@@ -3233,11 +3758,11 @@ convertible to `bool`.
 ``` cpp
 template<class T, class U> constexpr bool operator<(const optional<T>& x, const optional<U>& y);
 ```
-*Mandates:* `*x < *y` is well-formed and its result is convertible to
 `bool`.
 *Returns:* If `!y`, `false`; otherwise, if `!x`, `true`; otherwise
 `*x < *y`.
@@ -3246,11 +3771,11 @@ is a core constant expression are constexpr functions.
 ``` cpp
 template<class T, class U> constexpr bool operator>(const optional<T>& x, const optional<U>& y);
 ```
-*Mandates:* The expression `*x > *y` is well-formed and its result is
 convertible to `bool`.
 *Returns:* If `!x`, `false`; otherwise, if `!y`, `true`; otherwise
 `*x > *y`.
@@ -3259,12 +3784,12 @@ is a core constant expression are constexpr functions.
 ``` cpp
 template<class T, class U> constexpr bool operator<=(const optional<T>& x, const optional<U>& y);
 ```
-*Mandates:* The expression `*x <= *y` is well-formed and its result is
-convertible to `bool`.
 *Returns:* If `!x`, `true`; otherwise, if `!y`, `false`; otherwise
 `*x <= *y`.
 *Remarks:* Specializations of this function template for which
@@ -3272,12 +3797,12 @@ convertible to `bool`.
 ``` cpp
 template<class T, class U> constexpr bool operator>=(const optional<T>& x, const optional<U>& y);
 ```
-*Mandates:* The expression `*x >= *y` is well-formed and its result is
-convertible to `bool`.
 *Returns:* If `!y`, `true`; otherwise, if `!x`, `false`; otherwise
 `*x >= *y`.
 *Remarks:* Specializations of this function template for which
@@ -3313,113 +3838,113 @@ template<class T> constexpr strong_ordering operator<=>(const optional<T>& x, nu
 ``` cpp
 template<class T, class U> constexpr bool operator==(const optional<T>& x, const U& v);
 ```
-*Mandates:* The expression `*x == v` is well-formed and its result is
-convertible to `bool`.
 [*Note 1*: `T` need not be *Cpp17EqualityComparable*. — *end note*]
 *Effects:* Equivalent to: `return x.has_value() ? *x == v : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator==(const T& v, const optional<U>& x);
 ```
-*Mandates:* The expression `v == *x` is well-formed and its result is
-convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? v == *x : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator!=(const optional<T>& x, const U& v);
 ```
-*Mandates:* The expression `*x != v` is well-formed and its result is
-convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? *x != v : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator!=(const T& v, const optional<U>& x);
 ```
-*Mandates:* The expression `v != *x` is well-formed and its result is
-convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? v != *x : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<(const optional<T>& x, const U& v);
 ```
-*Mandates:* The expression `*x < v` is well-formed and its result is
-convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? *x < v : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<(const T& v, const optional<U>& x);
 ```
-*Mandates:* The expression `v < *x` is well-formed and its result is
-convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? v < *x : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>(const optional<T>& x, const U& v);
 ```
-*Mandates:* The expression `*x > v` is well-formed and its result is
-convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? *x > v : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>(const T& v, const optional<U>& x);
 ```
-*Mandates:* The expression `v > *x` is well-formed and its result is
-convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? v > *x : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<=(const optional<T>& x, const U& v);
 ```
-*Mandates:* The expression `*x <= v` is well-formed and its result is
-convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? *x <= v : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<=(const T& v, const optional<U>& x);
 ```
-*Mandates:* The expression `v <= *x` is well-formed and its result is
-convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? v <= *x : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>=(const optional<T>& x, const U& v);
 ```
-*Mandates:* The expression `*x >= v` is well-formed and its result is
-convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? *x >= v : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>=(const T& v, const optional<U>& x);
 ```
-*Mandates:* The expression `v >= *x` is well-formed and its result is
-convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? v >= *x : true;`
 ``` cpp
 template<class T, class U>
@@ -3436,19 +3961,27 @@ template<class T, class U>
 ``` cpp
 template<class T>
   constexpr void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y)));
 ```
-*Constraints:* `is_move_constructible_v<T>` is `true` and
-`is_swappable_v<T>` is `true`.
 *Effects:* Calls `x.swap(y)`.
 ``` cpp
 template<class T> constexpr optional<decay_t<T>> make_optional(T&& v);
 ```
 *Returns:* `optional<decay_t<T>>(std::forward<T>(v))`.
 ``` cpp
 template<class T, class...Args>
   constexpr optional<T> make_optional(Args&&... args);
@@ -3479,20 +4012,24 @@ object `o` of type `optional<T>`, if `o.has_value() == true`, then
 unspecified value. The member functions are not guaranteed to be
 `noexcept`.
 ## Variants <a id="variant">[[variant]]</a>
-### In general <a id="variant.general">[[variant.general]]</a>
 A variant object holds and manages the lifetime of a value. If the
 `variant` holds a value, that value’s type has to be one of the template
 argument types given to `variant`. These template arguments are called
 alternatives.
 ### Header `<variant>` synopsis <a id="variant.syn">[[variant.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
 namespace std {
   // [variant.variant], class template variant
   template<class... Types>
@@ -3508,11 +4045,11 @@ namespace std {
     struct variant_size<variant<Types...>>;
   template<size_t I, class T> struct variant_alternative;       // not defined
   template<size_t I, class T> struct variant_alternative<I, const T>;
   template<size_t I, class T>
-    using variant_alternative_t = typename variant_alternative<I, T>::type;
   template<size_t I, class... Types>
     struct variant_alternative<I, variant<Types...>>;
   inline constexpr size_t variant_npos = -1;
@@ -3520,26 +4057,30 @@ namespace std {
   // [variant.get], value access
   template<class T, class... Types>
     constexpr bool holds_alternative(const variant<Types...>&) noexcept;
   template<size_t I, class... Types>
-    constexpr variant_alternative_t<I, variant<Types...>>& get(variant<Types...>&);
   template<size_t I, class... Types>
-    constexpr variant_alternative_t<I, variant<Types...>>&& get(variant<Types...>&&);
   template<size_t I, class... Types>
-    constexpr const variant_alternative_t<I, variant<Types...>>& get(const variant<Types...>&);
   template<size_t I, class... Types>
-    constexpr const variant_alternative_t<I, variant<Types...>>&& get(const variant<Types...>&&);
   template<class T, class... Types>
-    constexpr T& get(variant<Types...>&);
   template<class T, class... Types>
-    constexpr T&& get(variant<Types...>&&);
   template<class T, class... Types>
-    constexpr const T& get(const variant<Types...>&);
   template<class T, class... Types>
-    constexpr const T&& get(const variant<Types...>&&);
   template<size_t I, class... Types>
     constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
       get_if(variant<Types...>*) noexcept;
   template<size_t I, class... Types>
@@ -3648,28 +4189,35 @@ namespace std {
     constexpr bool valueless_by_exception() const noexcept;
     constexpr size_t index() const noexcept;
     // [variant.swap], swap
     constexpr void swap(variant&) noexcept(see below);
   };
 }
 ```
 Any instance of `variant` at any given time either holds a value of one
 of its alternative types or holds no value. When an instance of
 `variant` holds a value of alternative type `T`, it means that a value
 of type `T`, referred to as the `variant` object’s *contained value*, is
-allocated within the storage of the `variant` object. Implementations
-are not permitted to use additional storage, such as dynamic memory, to
-allocate the contained value.
 All types in `Types` shall meet the *Cpp17Destructible* requirements (
 [[cpp17.destructible]]).
 A program that instantiates the definition of `variant` with no template
 arguments is ill-formed.
 #### Constructors <a id="variant.ctor">[[variant.ctor]]</a>
 In the descriptions that follow, let i be in the range \[`0`,
 `sizeof...(Types)`), and `Tᵢ` be the iᵗʰ type in `Types`.
@@ -3697,11 +4245,11 @@ equivalent to `is_nothrow_default_constructible_v<``T₀``>`.
 constexpr variant(const variant& w);
 ```
 *Effects:* If `w` holds a value, initializes the `variant` to hold the
 same alternative as `w` and direct-initializes the contained value with
-`get<j>(w)`, where `j` is `w.index()`. Otherwise, initializes the
 `variant` to not hold a value.
 *Throws:* Any exception thrown by direct-initializing any `Tᵢ` for all
 i.
@@ -3716,12 +4264,12 @@ constexpr variant(variant&& w) noexcept(see below);
 *Constraints:* `is_move_constructible_v<``Tᵢ``>` is `true` for all i.
 *Effects:* If `w` holds a value, initializes the `variant` to hold the
 same alternative as `w` and direct-initializes the contained value with
-`get<j>(std::move(w))`, where `j` is `w.index()`. Otherwise, initializes
-the `variant` to not hold a value.
 *Throws:* Any exception thrown by move-constructing any `Tᵢ` for all i.
 *Remarks:* The exception specification is equivalent to the logical of
 `is_nothrow_move_constructible_v<``Tᵢ``>` for all i. If
@@ -3875,11 +4423,11 @@ Let j be `rhs.index()`.
   value contained in `*this` and sets `*this` to not hold a value.
 - Otherwise, if `index() == `j, assigns the value contained in `rhs` to
   the value contained in `*this`.
 - Otherwise, if either `is_nothrow_copy_constructible_v<``Tⱼ``>` is
   `true` or `is_nothrow_move_constructible_v<``Tⱼ``>` is `false`,
-  equivalent to `emplace<`j`>(get<`j`>(rhs))`.
 - Otherwise, equivalent to `operator=(variant(rhs))`.
 *Ensures:* `index() == rhs.index()`.
 *Returns:* `*this`.
@@ -3903,13 +4451,14 @@ Let j be `rhs.index()`.
 *Effects:*
 - If neither `*this` nor `rhs` holds a value, there is no effect.
 - Otherwise, if `*this` holds a value but `rhs` does not, destroys the
   value contained in `*this` and sets `*this` to not hold a value.
-- Otherwise, if `index() == `j, assigns `get<`j`>(std::move(rhs))` to
-  the value contained in `*this`.
-- Otherwise, equivalent to `emplace<`j`>(get<`j`>(std::move(rhs)))`.
 *Returns:* `*this`.
 *Remarks:* If `is_trivially_move_constructible_v<``Tᵢ``> &&`
 `is_trivially_move_assignable_v<``Tᵢ``> &&`
@@ -4107,26 +4656,27 @@ requirements [[swappable.requirements]].
 *Effects:*
 - If `valueless_by_exception() && rhs.valueless_by_exception()` no
   effect.
 - Otherwise, if `index() == rhs.index()`, calls
-  `swap(get<`i`>(*this), get<`i`>(rhs))` where i is `index()`.
 - Otherwise, exchanges values of `rhs` and `*this`.
 *Throws:* If `index() == rhs.index()`, any exception thrown by
-`swap(get<`i`>(*this), get<`i`>(rhs))` with i being `index()`.
-Otherwise, any exception thrown by the move constructor of `Tᵢ` or `Tⱼ`
-with i being `index()` and j being `rhs.index()`.
 *Remarks:* If an exception is thrown during the call to function
-`swap(get<`i`>(*this), get<`i`>(rhs))`, the states of the contained
-values of `*this` and of `rhs` are determined by the exception safety
-guarantee of `swap` for lvalues of `Tᵢ` with i being `index()`. If an
-exception is thrown during the exchange of the values of `*this` and
-`rhs`, the states of the values of `*this` and of `rhs` are determined
-by the exception safety guarantee of `variant`’s move constructor. The
-exception specification is equivalent to the logical of
 `is_nothrow_move_constructible_v<``Tᵢ``> && is_nothrow_swappable_v<``Tᵢ``>`
 for all i.
 ### `variant` helper classes <a id="variant.helper">[[variant.helper]]</a>
@@ -4157,19 +4707,19 @@ template<size_t I, class T> struct variant_alternative<I, const T>;
 ```
 Let `VA` denote `variant_alternative<I, T>` of the cv-unqualified type
 `T`. Then each specialization of the template meets the
 *Cpp17TransformationTrait* requirements [[meta.rqmts]] with a member
-typedef `type` that names the type `add_const_t<VA::type>`.
 ``` cpp
 variant_alternative<I, variant<Types...>>::type
 ```
 *Mandates:* `I` < `sizeof...(Types)`.
-*Type:* The type `T_I`.
 ### Value access <a id="variant.get">[[variant.get]]</a>
 ``` cpp
 template<class T, class... Types>
@@ -4179,10 +4729,31 @@ template<class T, class... Types>
 *Mandates:* The type `T` occurs exactly once in `Types`.
 *Returns:* `true` if `index()` is equal to the zero-based index of `T`
 in `Types`.
 ``` cpp
 template<size_t I, class... Types>
   constexpr variant_alternative_t<I, variant<Types...>>& get(variant<Types...>& v);
 template<size_t I, class... Types>
   constexpr variant_alternative_t<I, variant<Types...>>&& get(variant<Types...>&& v);
@@ -4243,81 +4814,83 @@ zero-based index of `T` in `Types`.
 ``` cpp
 template<class... Types>
   constexpr bool operator==(const variant<Types...>& v, const variant<Types...>& w);
 ```
-*Mandates:* `get<`i`>(v) == get<`i`>(w)` is a valid expression that is
-convertible to `bool`, for all i.
 *Returns:* If `v.index() != w.index()`, `false`; otherwise if
 `v.valueless_by_exception()`, `true`; otherwise
-`get<`i`>(v) == get<`i`>(w)` with i being `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator!=(const variant<Types...>& v, const variant<Types...>& w);
 ```
-*Mandates:* `get<`i`>(v) != get<`i`>(w)` is a valid expression that is
-convertible to `bool`, for all i.
 *Returns:* If `v.index() != w.index()`, `true`; otherwise if
 `v.valueless_by_exception()`, `false`; otherwise
-`get<`i`>(v) != get<`i`>(w)` with i being `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator<(const variant<Types...>& v, const variant<Types...>& w);
 ```
-*Mandates:* `get<`i`>(v) < get<`i`>(w)` is a valid expression that is
-convertible to `bool`, for all i.
 *Returns:* If `w.valueless_by_exception()`, `false`; otherwise if
 `v.valueless_by_exception()`, `true`; otherwise, if
 `v.index() < w.index()`, `true`; otherwise if `v.index() > w.index()`,
-`false`; otherwise `get<`i`>(v) < get<`i`>(w)` with i being `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator>(const variant<Types...>& v, const variant<Types...>& w);
 ```
-*Mandates:* `get<`i`>(v) > get<`i`>(w)` is a valid expression that is
-convertible to `bool`, for all i.
 *Returns:* If `v.valueless_by_exception()`, `false`; otherwise if
 `w.valueless_by_exception()`, `true`; otherwise, if
 `v.index() > w.index()`, `true`; otherwise if `v.index() < w.index()`,
-`false`; otherwise `get<`i`>(v) > get<`i`>(w)` with i being `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator<=(const variant<Types...>& v, const variant<Types...>& w);
 ```
-*Mandates:* `get<`i`>(v) <= get<`i`>(w)` is a valid expression that is
-convertible to `bool`, for all i.
 *Returns:* If `v.valueless_by_exception()`, `true`; otherwise if
 `w.valueless_by_exception()`, `false`; otherwise, if
 `v.index() < w.index()`, `true`; otherwise if `v.index() > w.index()`,
-`false`; otherwise `get<`i`>(v) <= get<`i`>(w)` with i being
 `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator>=(const variant<Types...>& v, const variant<Types...>& w);
 ```
-*Mandates:* `get<`i`>(v) >= get<`i`>(w)` is a valid expression that is
-convertible to `bool`, for all i.
 *Returns:* If `w.valueless_by_exception()`, `true`; otherwise if
 `v.valueless_by_exception()`, `false`; otherwise, if
 `v.index() > w.index()`, `true`; otherwise if `v.index() < w.index()`,
-`false`; otherwise `get<`i`>(v) >= get<`i`>(w)` with i being
 `v.index()`.
 ``` cpp
 template<class... Types> requires (three_way_comparable<Types> && ...)
   constexpr common_comparison_category_t<compare_three_way_result_t<Types>...>
@@ -4330,11 +4903,11 @@ template<class... Types> requires (three_way_comparable<Types> && ...)
 if (v.valueless_by_exception() && w.valueless_by_exception())
   return strong_ordering::equal;
 if (v.valueless_by_exception()) return strong_ordering::less;
 if (w.valueless_by_exception()) return strong_ordering::greater;
 if (auto c = v.index() <=> w.index(); c != 0) return c;
-return get<i>(v) <=> get<i>(w);
 ```
 with i being `v.index()`.
 ### Visitation <a id="variant.visit">[[variant.visit]]</a>
@@ -4349,17 +4922,17 @@ template<class R, class Visitor, class... Variants>
 Let *as-variant* denote the following exposition-only function
 templates:
 ``` cpp
 template<class... Ts>
-  auto&& as-variant(variant<Ts...>& var) { return var; }
 template<class... Ts>
-  auto&& as-variant(const variant<Ts...>& var) { return var; }
 template<class... Ts>
-  auto&& as-variant(variant<Ts...>&& var) { return std::move(var); }
 template<class... Ts>
-  auto&& as-variant(const variant<Ts...>&& var) { return std::move(var); }
 ```
 Let n be `sizeof...(Variants)`. For each 0 ≤ i < n, let `Vᵢ` denote the
 type
 `decltype(`*`as-variant`*`(``std::forward<``Variantsᵢ``>(``varsᵢ``)``))`.
@@ -4371,17 +4944,17 @@ Let `V` denote the pack of types `Vᵢ`.
 Let m be a pack of n values of type `size_t`. Such a pack is valid if
 0 ≤ mᵢ < `variant_size_v<remove_reference_t<Vᵢ``>>` for all 0 ≤ i < n.
 For each valid pack m, let e(m) denote the expression:
 ``` cpp
-INVOKE(std::forward<Visitor>(vis), get<m>(std::forward<V>(vars))...)  // see [func.require]
 ```
 for the first form and
 ``` cpp
-INVOKE<R>(std::forward<Visitor>(vis), get<m>(std::forward<V>(vars))...)  // see [func.require]
 ```
 for the second form.
 *Mandates:* For each valid pack m, e(m) is a valid expression. All such
@@ -4397,10 +4970,37 @@ expressions are of the same type and value category.
 *Complexity:* For n ≤ 1, the invocation of the callable object is
 implemented in constant time, i.e., for n = 1, it does not depend on the
 number of alternative types of `V₀`. For n > 1, the invocation of the
 callable object has no complexity requirements.
 ### Class `monostate` <a id="variant.monostate">[[variant.monostate]]</a>
 ``` cpp
 struct monostate{};
 ```
@@ -4440,23 +5040,24 @@ for all i.
 ``` cpp
 namespace std {
   class bad_variant_access : public exception {
   public:
     // see [exception] for the specification of the special member functions
-    const char* what() const noexcept override;
   };
 }
 ```
 Objects of type `bad_variant_access` are thrown to report invalid
 accesses to the value of a `variant` object.
 ``` cpp
-const char* what() const noexcept override;
 ```
-*Returns:* An *implementation-defined* NTBS.
 ### Hash support <a id="variant.hash">[[variant.hash]]</a>
 ``` cpp
 template<class... Types> struct hash<variant<Types...>>;
@@ -4904,12 +5505,15 @@ template<class T>
   const T* any_cast(const any* operand) noexcept;
 template<class T>
   T* any_cast(any* operand) noexcept;
 ```
-*Returns:* If `operand != nullptr && operand->type() == typeid(T)`, a
-pointer to the object contained by `operand`; otherwise, `nullptr`.
 [*Example 2*:
 ``` cpp
 bool is_string(const any& operand) {
@@ -4919,20 +5523,21 @@ bool is_string(const any& operand) {
 — *end example*]
 ## Expected objects <a id="expected">[[expected]]</a>
-### In general <a id="expected.general">[[expected.general]]</a>
 Subclause [[expected]] describes the class template `expected` that
 represents expected objects. An `expected<T, E>` object holds an object
-of type `T` or an object of type `unexpected<E>` and manages the
-lifetime of the contained objects.
 ### Header `<expected>` synopsis <a id="expected.syn">[[expected.syn]]</a>
 ``` cpp
 namespace std {
   // [expected.unexpected], class template unexpected
   template<class E> class unexpected;
   // [expected.bad], class template bad_expected_access
@@ -4946,14 +5551,14 @@ namespace std {
     explicit unexpect_t() = default;
   };
   inline constexpr unexpect_t unexpect{};
   // [expected.expected], class template expected
-  template<class T, class E> class expected;
   // [expected.void], partial specialization of expected for void types
-  template<class T, class E> requires is_void_v<T> class expected<T, E>;
 }
 ```
 ### Class template `unexpected` <a id="expected.unexpected">[[expected.unexpected]]</a>
@@ -5100,16 +5705,16 @@ its result is convertible to `bool`.
 ``` cpp
 namespace std {
   template<class E>
   class bad_expected_access : public bad_expected_access<void> {
   public:
-    explicit bad_expected_access(E);
-    const char* what() const noexcept override;
-    E& error() & noexcept;
-    const E& error() const & noexcept;
-    E&& error() && noexcept;
-    const E&& error() const && noexcept;
   private:
     E unex;             // exposition only
   };
 }
@@ -5119,60 +5724,62 @@ The class template `bad_expected_access` defines the type of objects
 thrown as exceptions to report the situation where an attempt is made to
 access the value of an `expected<T, E>` object for which `has_value()`
 is `false`.
 ``` cpp
-explicit bad_expected_access(E e);
 ```
 *Effects:* Initializes *unex* with `std::move(e)`.
 ``` cpp
-const E& error() const & noexcept;
-E& error() & noexcept;
 ```
 *Returns:* *unex*.
 ``` cpp
-E&& error() && noexcept;
-const E&& error() const && noexcept;
 ```
 *Returns:* `std::move(`*`unex`*`)`.
 ``` cpp
-const char* what() const noexcept override;
 ```
-*Returns:* An implementation-defined NTBS.
 ### Class template specialization `bad_expected_access<void>` <a id="expected.bad.void">[[expected.bad.void]]</a>
 ``` cpp
 namespace std {
   template<>
   class bad_expected_access<void> : public exception {
   protected:
-    bad_expected_access() noexcept;
-    bad_expected_access(const bad_expected_access&);
-    bad_expected_access(bad_expected_access&&);
-    bad_expected_access& operator=(const bad_expected_access&);
-    bad_expected_access& operator=(bad_expected_access&&);
-    ~bad_expected_access();
   public:
-    const char* what() const noexcept override;
   };
 }
 ```
 ``` cpp
-const char* what() const noexcept override;
 ```
-*Returns:* An implementation-defined NTBS.
 ### Class template `expected` <a id="expected.expected">[[expected.expected]]</a>
 #### General <a id="expected.object.general">[[expected.object.general]]</a>
@@ -5195,11 +5802,11 @@ namespace std {
     template<class U, class G>
       constexpr explicit(see below) expected(const expected<U, G>&);
     template<class U, class G>
       constexpr explicit(see below) expected(expected<U, G>&&);
-    template<class U = T>
       constexpr explicit(see below) expected(U&& v);
     template<class G>
       constexpr explicit(see below) expected(const unexpected<G>&);
     template<class G>
@@ -5218,11 +5825,11 @@ namespace std {
     constexpr ~expected();
     // [expected.object.assign], assignment
     constexpr expected& operator=(const expected&);
     constexpr expected& operator=(expected&&) noexcept(see below);
-    template<class U = T> constexpr expected& operator=(U&&);
     template<class G>
       constexpr expected& operator=(const unexpected<G>&);
     template<class G>
       constexpr expected& operator=(unexpected<G>&&);
@@ -5242,20 +5849,20 @@ namespace std {
     constexpr T& operator*() & noexcept;
     constexpr const T&& operator*() const && noexcept;
     constexpr T&& operator*() && noexcept;
     constexpr explicit operator bool() const noexcept;
     constexpr bool has_value() const noexcept;
-    constexpr const T& value() const &;
-    constexpr T& value() &;
-    constexpr const T&& value() const &&;
-    constexpr T&& value() &&;
     constexpr const E& error() const & noexcept;
     constexpr E& error() & noexcept;
     constexpr const E&& error() const && noexcept;
     constexpr E&& error() && noexcept;
-    template<class U> constexpr T value_or(U&&) const &;
-    template<class U> constexpr T value_or(U&&) &&;
     template<class G = E> constexpr E error_or(G&&) const &;
     template<class G = E> constexpr E error_or(G&&) &&;
     // [expected.object.monadic], monadic operations
     template<class F> constexpr auto and_then(F&& f) &;
@@ -5292,15 +5899,13 @@ namespace std {
   };
 }
 ```
 Any object of type `expected<T, E>` either contains a value of type `T`
-or a value of type `E` within its own storage. Implementations are not
-permitted to use additional storage, such as dynamic memory, to allocate
-the object of type `T` or the object of type `E`. Member *`has_val`*
-indicates whether the `expected<T, E>` object contains an object of type
-`T`.
 A type `T` is a *valid value type for `expected`*, if `remove_cv_t<T>`
 is `void` or a complete non-array object type that is not `in_place_t`,
 `unexpect_t`, or a specialization of `unexpected`. A program which
 instantiates class template `expected<T, E>` with an argument `T` that
@@ -5416,18 +6021,19 @@ with `std::forward<GF>(rhs.error())`.
 *Remarks:* The expression inside `explicit` is equivalent to
 `!is_convertible_v<UF, T> || !is_convertible_v<GF, E>`.
 ``` cpp
-template<class U = T>
   constexpr explicit(!is_convertible_v<U, T>) expected(U&& v);
 ```
 *Constraints:*
 - `is_same_v<remove_cvref_t<U>, in_place_t>` is `false`; and
-- `is_same_v<expected, remove_cvref_t<U>>` is `false`; and
 - `remove_cvref_t<U>` is not a specialization of `unexpected`; and
 - `is_constructible_v<T, U>` is `true`; and
 - if `T` is cv `bool`, `remove_cvref_t<U>` is not a specialization of
   `expected`.
@@ -5527,11 +6133,12 @@ destroys *unex*.
 `is_trivially_destructible_v<E>` is `true`, then this destructor is a
 trivial destructor.
 #### Assignment <a id="expected.object.assign">[[expected.object.assign]]</a>
-This subclause makes use of the following exposition-only function:
 ``` cpp
 template<class T, class U, class... Args>
 constexpr void reinit-expected(T& newval, U& oldval, Args&&... args) {  // exposition only
   if constexpr (is_nothrow_constructible_v<T, Args...>) {
@@ -5624,11 +6231,11 @@ Then, if no exception was thrown, equivalent to:
 is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T> &&
 is_nothrow_move_assignable_v<E> && is_nothrow_move_constructible_v<E>
 ```
 ``` cpp
-template<class U = T>
   constexpr expected& operator=(U&& v);
 ```
 *Constraints:*
@@ -5740,12 +6347,12 @@ constexpr void swap(expected& rhs) noexcept(see below);
 | \topline | `this->has_value()` | `!this->has_value()` |
 | -------- | ------------------- | -------------------- |
-For the case where `rhs.value()` is `false` and `this->has_value()` is
-`true`, equivalent to:
 ``` cpp
 if constexpr (is_nothrow_move_constructible_v<E>) {
   E tmp(std::move(rhs.unex));
   destroy_at(addressof(rhs.unex));
@@ -5793,29 +6400,29 @@ friend constexpr void swap(expected& x, expected& y) noexcept(noexcept(x.swap(y)
 ``` cpp
 constexpr const T* operator->() const noexcept;
 constexpr T* operator->() noexcept;
 ```
-*Preconditions:* `has_value()` is `true`.
 *Returns:* `addressof(`*`val`*`)`.
 ``` cpp
 constexpr const T& operator*() const & noexcept;
 constexpr T& operator*() & noexcept;
 ```
-*Preconditions:* `has_value()` is `true`.
 *Returns:* *val*.
 ``` cpp
 constexpr T&& operator*() && noexcept;
 constexpr const T&& operator*() const && noexcept;
 ```
-*Preconditions:* `has_value()` is `true`.
 *Returns:* `std::move(`*`val`*`)`.
 ``` cpp
 constexpr explicit operator bool() const noexcept;
@@ -5852,34 +6459,34 @@ constexpr const T&& value() const &&;
 ``` cpp
 constexpr const E& error() const & noexcept;
 constexpr E& error() & noexcept;
 ```
-*Preconditions:* `has_value()` is `false`.
 *Returns:* *unex*.
 ``` cpp
 constexpr E&& error() && noexcept;
 constexpr const E&& error() const && noexcept;
 ```
-*Preconditions:* `has_value()` is `false`.
 *Returns:* `std::move(`*`unex`*`)`.
 ``` cpp
-template<class U> constexpr T value_or(U&& v) const &;
 ```
 *Mandates:* `is_copy_constructible_v<T>` is `true` and
 `is_convertible_v<U, T>` is `true`.
 *Returns:* `has_value() ? **this : static_cast<T>(std::forward<U>(v))`.
 ``` cpp
-template<class U> constexpr T value_or(U&& v) &&;
 ```
 *Mandates:* `is_move_constructible_v<T>` is `true` and
 `is_convertible_v<U, T>` is `true`.
@@ -5911,45 +6518,45 @@ template<class G = E> constexpr E error_or(G&& e) &&;
 ``` cpp
 template<class F> constexpr auto and_then(F&& f) &;
 template<class F> constexpr auto and_then(F&& f) const &;
 ```
-Let `U` be `remove_cvref_t<invoke_result_t<F, decltype(value())>>`.
 *Constraints:* `is_constructible_v<E, decltype(error())>` is `true`.
 *Mandates:* `U` is a specialization of `expected` and
-`is_same_v<U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
-  return invoke(std::forward<F>(f), value());
 else
   return U(unexpect, error());
 ```
 ``` cpp
 template<class F> constexpr auto and_then(F&& f) &&;
 template<class F> constexpr auto and_then(F&& f) const &&;
 ```
 Let `U` be
-`remove_cvref_t<invoke_result_t<F, decltype(std::move(value()))>>`.
 *Constraints:* `is_constructible_v<E, decltype(std::move(error()))>` is
 `true`.
 *Mandates:* `U` is a specialization of `expected` and
-`is_same_v<U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
-  return invoke(std::forward<F>(f), std::move(value()));
 else
   return U(unexpect, std::move(error()));
 ```
 ``` cpp
@@ -5957,20 +6564,20 @@ template<class F> constexpr auto or_else(F&& f) &;
 template<class F> constexpr auto or_else(F&& f) const &;
 ```
 Let `G` be `remove_cvref_t<invoke_result_t<F, decltype(error())>>`.
-*Constraints:* `is_constructible_v<T, decltype(value())>` is `true`.
 *Mandates:* `G` is a specialization of `expected` and
-`is_same_v<G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
-  return G(in_place, value());
 else
   return invoke(std::forward<F>(f), error());
 ```
 ``` cpp
@@ -5979,39 +6586,39 @@ template<class F> constexpr auto or_else(F&& f) const &&;
 ```
 Let `G` be
 `remove_cvref_t<invoke_result_t<F, decltype(std::move(error()))>>`.
-*Constraints:* `is_constructible_v<T, decltype(std::move(value()))>` is
-`true`.
 *Mandates:* `G` is a specialization of `expected` and
-`is_same_v<G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
-  return G(in_place, std::move(value()));
 else
   return invoke(std::forward<F>(f), std::move(error()));
 ```
 ``` cpp
 template<class F> constexpr auto transform(F&& f) &;
 template<class F> constexpr auto transform(F&& f) const &;
 ```
-Let `U` be `remove_cv_t<invoke_result_t<F, decltype(value())>>`.
 *Constraints:* `is_constructible_v<E, decltype(error())>` is `true`.
 *Mandates:* `U` is a valid value type for `expected`. If `is_void_v<U>`
 is `false`, the declaration
 ``` cpp
-U u(invoke(std::forward<F>(f), value()));
 ```
 is well-formed.
 *Effects:*
@@ -6019,53 +6626,54 @@ is well-formed.
 - If `has_value()` is `false`, returns
   `expected<U, E>(unexpect, error())`.
 - Otherwise, if `is_void_v<U>` is `false`, returns an `expected<U, E>`
   object whose *has_val* member is `true` and *val* member is
   direct-non-list-initialized with
-  `invoke(std::forward<F>(f), value())`.
-- Otherwise, evaluates `invoke(std::forward<F>(f), value())` and then
   returns `expected<U, E>()`.
 ``` cpp
 template<class F> constexpr auto transform(F&& f) &&;
 template<class F> constexpr auto transform(F&& f) const &&;
 ```
 Let `U` be
-`remove_cv_t<invoke_result_t<F, decltype(std::move(value()))>>`.
 *Constraints:* `is_constructible_v<E, decltype(std::move(error()))>` is
 `true`.
 *Mandates:* `U` is a valid value type for `expected`. If `is_void_v<U>`
 is `false`, the declaration
 ``` cpp
-U u(invoke(std::forward<F>(f), std::move(value())));
 ```
-is well-formed for some invented variable `u`.
 *Effects:*
 - If `has_value()` is `false`, returns
   `expected<U, E>(unexpect, std::move(error()))`.
 - Otherwise, if `is_void_v<U>` is `false`, returns an `expected<U, E>`
   object whose *has_val* member is `true` and *val* member is
   direct-non-list-initialized with
-  `invoke(std::forward<F>(f), std::move(value()))`.
-- Otherwise, evaluates `invoke(std::forward<F>(f), std::move(value()))`
- and then returns `expected<U, E>()`.
 ``` cpp
 template<class F> constexpr auto transform_error(F&& f) &;
 template<class F> constexpr auto transform_error(F&& f) const &;
 ```
 Let `G` be `remove_cv_t<invoke_result_t<F, decltype(error())>>`.
-*Constraints:* `is_constructible_v<T, decltype(value())>` is `true`.
 *Mandates:* `G` is a valid template argument for `unexpected`
 [[expected.un.general]] and the declaration
 ``` cpp
@@ -6073,11 +6681,11 @@ G g(invoke(std::forward<F>(f), error()));
 ```
 is well-formed.
 *Returns:* If `has_value()` is `true`,
-`expected<T, G>(in_place, value())`; otherwise, an `expected<T, G>`
 object whose *has_val* member is `false` and *unex* member is
 direct-non-list-initialized with `invoke(std::forward<F>(f), error())`.
 ``` cpp
 template<class F> constexpr auto transform_error(F&& f) &&;
@@ -6085,12 +6693,12 @@ template<class F> constexpr auto transform_error(F&& f) const &&;
 ```
 Let `G` be
 `remove_cv_t<invoke_result_t<F, decltype(std::move(error()))>>`.
-*Constraints:* `is_constructible_v<T, decltype(std::move(value()))>` is
-`true`.
 *Mandates:* `G` is a valid template argument for `unexpected`
 [[expected.un.general]] and the declaration
 ``` cpp
@@ -6098,11 +6706,11 @@ G g(invoke(std::forward<F>(f), std::move(error())));
 ```
 is well-formed.
 *Returns:* If `has_value()` is `true`,
-`expected<T, G>(in_place, std::move(value()))`; otherwise, an
 `expected<T, G>` object whose *has_val* member is `false` and *unex*
 member is direct-non-list-initialized with
 `invoke(std::forward<F>(f), std::move(error()))`.
 #### Equality operators <a id="expected.object.eq">[[expected.object.eq]]</a>
@@ -6110,34 +6718,35 @@ member is direct-non-list-initialized with
 ``` cpp
 template<class T2, class E2> requires (!is_void_v<T2>)
   friend constexpr bool operator==(const expected& x, const expected<T2, E2>& y);
 ```
-*Mandates:* The expressions `*x == *y` and `x.error() == y.error()` are
-well-formed and their results are convertible to `bool`.
 *Returns:* If `x.has_value()` does not equal `y.has_value()`, `false`;
 otherwise if `x.has_value()` is `true`, `*x == *y`; otherwise
 `x.error() == y.error()`.
 ``` cpp
 template<class T2> friend constexpr bool operator==(const expected& x, const T2& v);
 ```
-*Mandates:* The expression `*x == v` is well-formed and its result is
-convertible to `bool`.
 [*Note 1*: `T` need not be *Cpp17EqualityComparable*. — *end note*]
 *Returns:* `x.has_value() && static_cast<bool>(*x == v)`.
 ``` cpp
 template<class E2> friend constexpr bool operator==(const expected& x, const unexpected<E2>& e);
 ```
-*Mandates:* The expression `x.error() == e.error()` is well-formed and
-its result is convertible to `bool`.
 *Returns:*
 `!x.has_value() && static_cast<bool>(x.error() == e.error())`.
 ### Partial specialization of `expected` for `void` types <a id="expected.void">[[expected.void]]</a>
@@ -6194,12 +6803,12 @@ public:
   // [expected.void.obs], observers
   constexpr explicit operator bool() const noexcept;
   constexpr bool has_value() const noexcept;
   constexpr void operator*() const noexcept;
-  constexpr void value() const &;
-  constexpr void value() &&;
   constexpr const E& error() const & noexcept;
   constexpr E& error() & noexcept;
   constexpr const E&& error() const && noexcept;
   constexpr E&& error() && noexcept;
   template<class G = E> constexpr E error_or(G&&) const &;
@@ -6236,15 +6845,13 @@ private:
   };
 };
 ```
 Any object of type `expected<T, E>` either represents a value of type
-`T`, or contains a value of type `E` within its own storage.
-Implementations are not permitted to use additional storage, such as
-dynamic memory, to allocate the object of type `E`. Member *`has_val`*
-indicates whether the `expected<T, E>` object represents a value of type
-`T`.
 A program that instantiates the definition of the template
 `expected<T, E>` with a type for the `E` parameter that is not a valid
 template argument for `unexpected` is ill-formed.
@@ -6409,10 +7016,13 @@ constexpr expected& operator=(const expected& rhs);
 ``` cpp
 constexpr expected& operator=(expected&& rhs) noexcept(see below);
 ```
 *Effects:*
 - If `this->has_value() && rhs.has_value()` is `true`, no effects.
 - Otherwise, if `this->has_value()` is `true`, equivalent to:
   ``` cpp
@@ -6426,13 +7036,10 @@ constexpr expected& operator=(expected&& rhs) noexcept(see below);
 *Returns:* `*this`.
 *Remarks:* The exception specification is equivalent to
 `is_nothrow_move_constructible_v<E> && is_nothrow_move_assignable_v<E>`.
-This operator is defined as deleted unless `is_move_constructible_v<E>`
-is `true` and `is_move_assignable_v<E>` is `true`.
 ``` cpp
 template<class G>
   constexpr expected& operator=(const unexpected<G>& e);
 template<class G>
   constexpr expected& operator=(unexpected<G>&& e);
@@ -6477,12 +7084,12 @@ constexpr void swap(expected& rhs) noexcept(see below);
 | \topline | `this->has_value()` | `!this->has_value()` |
 | -------- | ------------------- | -------------------- |
-For the case where `rhs.value()` is `false` and `this->has_value()` is
-`true`, equivalent to:
 ``` cpp
 construct_at(addressof(unex), std::move(rhs.unex));
 destroy_at(addressof(rhs.unex));
 has_val = false;
@@ -6511,40 +7118,45 @@ constexpr bool has_value() const noexcept;
 ``` cpp
 constexpr void operator*() const noexcept;
 ```
-*Preconditions:* `has_value()` is `true`.
 ``` cpp
 constexpr void value() const &;
 ```
 *Throws:* `bad_expected_access(error())` if `has_value()` is `false`.
 ``` cpp
 constexpr void value() &&;
 ```
 *Throws:* `bad_expected_access(std::move(error()))` if `has_value()` is
 `false`.
 ``` cpp
 constexpr const E& error() const & noexcept;
 constexpr E& error() & noexcept;
 ```
-*Preconditions:* `has_value()` is `false`.
 *Returns:* *unex*.
 ``` cpp
 constexpr E&& error() && noexcept;
 constexpr const E&& error() const && noexcept;
 ```
-*Preconditions:* `has_value()` is `false`.
 *Returns:* `std::move(`*`unex`*`)`.
 ``` cpp
 template<class G = E> constexpr E error_or(G&& e) const &;
@@ -6576,11 +7188,11 @@ template<class F> constexpr auto and_then(F&& f) const &;
 Let `U` be `remove_cvref_t<invoke_result_t<F>>`.
 *Constraints:* `is_constructible_v<E, decltype(error())>>` is `true`.
 *Mandates:* `U` is a specialization of `expected` and
-`is_same_v<U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
@@ -6598,11 +7210,11 @@ Let `U` be `remove_cvref_t<invoke_result_t<F>>`.
 *Constraints:* `is_constructible_v<E, decltype(std::move(error()))>` is
 `true`.
 *Mandates:* `U` is a specialization of `expected` and
-`is_same_v<U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
@@ -6617,11 +7229,11 @@ template<class F> constexpr auto or_else(F&& f) const &;
 ```
 Let `G` be `remove_cvref_t<invoke_result_t<F, decltype(error())>>`.
 *Mandates:* `G` is a specialization of `expected` and
-`is_same_v<G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
@@ -6637,11 +7249,11 @@ template<class F> constexpr auto or_else(F&& f) const &&;
 Let `G` be
 `remove_cvref_t<invoke_result_t<F, decltype(std::move(error()))>>`.
 *Mandates:* `G` is a specialization of `expected` and
-`is_same_v<G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
@@ -6755,23 +7367,23 @@ member is direct-non-list-initialized with
 ``` cpp
 template<class T2, class E2> requires is_void_v<T2>
   friend constexpr bool operator==(const expected& x, const expected<T2, E2>& y);
 ```
-*Mandates:* The expression `x.error() == y.error()` is well-formed and
-its result is convertible to `bool`.
 *Returns:* If `x.has_value()` does not equal `y.has_value()`, `false`;
 otherwise `x.has_value() || static_cast<bool>(x.error() == y.error())`.
 ``` cpp
 template<class E2>
   friend constexpr bool operator==(const expected& x, const unexpected<E2>& e);
 ```
-*Mandates:* The expression `x.error() == e.error()` is well-formed and
-its result is convertible to `bool`.
 *Returns:*
 `!x.has_value() && static_cast<bool>(x.error() == e.error())`.
 ## Bitsets <a id="bitset">[[bitset]]</a>
@@ -6813,13 +7425,10 @@ namespace std {
 namespace std {
   template<size_t N> class bitset {
   public:
     // bit reference
     class reference {
-      friend class bitset;
-      constexpr reference() noexcept;
     public:
       constexpr reference(const reference&) = default;
       constexpr ~reference();
       constexpr reference& operator=(bool x) noexcept;              // for b[i] = x;
       constexpr reference& operator=(const reference&) noexcept;    // for b[i] = b[j];
@@ -6837,14 +7446,22 @@ namespace std {
         typename basic_string<charT, traits, Allocator>::size_type pos = 0,
         typename basic_string<charT, traits, Allocator>::size_type n
           = basic_string<charT, traits, Allocator>::npos,
         charT zero = charT('0'),
         charT one = charT('1'));
     template<class charT>
       constexpr explicit bitset(
         const charT* str,
-        typename basic_string<charT>::size_type n = basic_string<charT>::npos,
         charT zero = charT('0'),
         charT one = charT('1'));
     // [bitset.members], bitset operations
     constexpr bitset& operator&=(const bitset& rhs) noexcept;
@@ -6936,10 +7553,18 @@ template<class charT, class traits, class Allocator>
     typename basic_string<charT, traits, Allocator>::size_type pos = 0,
     typename basic_string<charT, traits, Allocator>::size_type n
       = basic_string<charT, traits, Allocator>::npos,
     charT zero = charT('0'),
     charT one = charT('1'));
 ```
 *Effects:* Determines the effective length `rlen` of the initializing
 string as the smaller of `n` and `str.size() - pos`. Initializes the
 first `M` bit positions to values determined from the corresponding
@@ -6961,21 +7586,21 @@ other than `zero` or `one`.
 ``` cpp
 template<class charT>
   constexpr explicit bitset(
     const charT* str,
-    typename basic_string<charT>::size_type n = basic_string<charT>::npos,
     charT zero = charT('0'),
     charT one = charT('1'));
 ```
 *Effects:* As if by:
 ``` cpp
-bitset(n == basic_string<charT>::npos
-          ? basic_string<charT>(str)
-          : basic_string<charT>(str, n),
        0, n, zero, one)
 ```
 #### Members <a id="bitset.members">[[bitset.members]]</a>
@@ -7113,22 +7738,22 @@ position.
 ``` cpp
 constexpr bool operator[](size_t pos) const;
 ```
-*Preconditions:* `pos` is valid.
 *Returns:* `true` if the bit at position `pos` in `*this` has the value
 one, otherwise `false`.
 *Throws:* Nothing.
 ``` cpp
 constexpr bitset::reference operator[](size_t pos);
 ```
-*Preconditions:* `pos` is valid.
 *Returns:* An object of type `bitset::reference` such that
 `(*this)[pos] == this->test(pos)`, and such that `(*this)[pos] = val` is
 equivalent to `this->set(pos, val)`.
@@ -7396,16 +8021,21 @@ namespace std {
   // [func.identity], identity
   struct identity;                                                                  // freestanding
   // [func.not.fn], function template not_fn
   template<class F> constexpr unspecified not_fn(F&& f);                            // freestanding
   // [func.bind.partial], function templates bind_front and bind_back
   template<class F, class... Args>
     constexpr unspecified bind_front(F&&, Args&&...);                               // freestanding
   template<class F, class... Args>
     constexpr unspecified bind_back(F&&, Args&&...);                                // freestanding
   // [func.bind], bind
   template<class T> struct is_bind_expression;                                      // freestanding
   template<class T>
     constexpr bool is_bind_expression_v =                                           // freestanding
@@ -7422,39 +8052,49 @@ namespace std {
   namespace placeholders {
     // M is the implementation-defined number of placeholders
     see belownc _1;                                                                   // freestanding
     see belownc _2;                                                                   // freestanding
- .
-               .
-               .
     see belownc _M;                                                                   // freestanding
   }
   // [func.memfn], member function adaptors
   template<class R, class T>
     constexpr unspecified mem_fn(R T::*) noexcept;                                  // freestanding
   // [func.wrap], polymorphic function wrappers
   class bad_function_call;
   template<class> class function;       // not defined
   template<class R, class... ArgTypes> class function<R(ArgTypes...)>;
-  // [func.wrap.func.alg], specialized algorithms
   template<class R, class... ArgTypes>
     void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
-  // [func.wrap.func.nullptr], null pointer comparison operator functions
   template<class R, class... ArgTypes>
     bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
-  // [func.wrap.move], move only wrapper
   template<class... S> class move_only_function;                        // not defined
   template<class R, class... ArgTypes>
     class move_only_function<R(ArgTypes...) cv ref noexcept(noex)>;     // see below
   // [func.search], searchers
   template<class ForwardIterator1, class BinaryPredicate = equal_to<>>
     class default_searcher;                                                         // freestanding
   template<class RandomAccessIterator,
@@ -7478,10 +8118,29 @@ namespace std {
     struct greater;                                                                 // freestanding
     struct less;                                                                    // freestanding
     struct greater_equal;                                                           // freestanding
     struct less_equal;                                                              // freestanding
   }
 }
 ```
 [*Example 1*:
@@ -7533,19 +8192,19 @@ collectively referred to as *state entities*.
 ### Requirements <a id="func.require">[[func.require]]</a>
 Define `INVOKE(f, t₁, t₂, …, t_N)` as follows:
 - `(t₁.*f)(t₂, …, t_N)` when `f` is a pointer to a member function of a
-  class `T` and `is_same_v<T, remove_cvref_t<decltype(t1)>> ||`
   `is_base_of_v<T, remove_cvref_t<decltype(t₁)>>` is `true`;
 - `(t₁.get().*f)(t₂, …, t_N)` when `f` is a pointer to a member function
   of a class `T` and `remove_cvref_t<decltype(t₁)>` is a specialization
   of `reference_wrapper`;
 - `((*t₁).*f)(t₂, …, t_N)` when `f` is a pointer to a member function of
   a class `T` and `t₁` does not satisfy the previous two items;
 - `t₁.*f` when N = 1 and `f` is a pointer to data member of a class `T`
-  and `is_same_v<T, remove_cvref_t<decltype(t1)>> ||`
   `is_base_of_v<T, remove_cvref_t<decltype(t₁)>>` is `true`;
 - `t₁.get().*f` when N = 1 and `f` is a pointer to data member of a
   class `T` and `remove_cvref_t<decltype(t₁)>` is a specialization of
   `reference_wrapper`;
 - `(*t₁).*f` when N = 1 and `f` is a pointer to data member of a class
@@ -7659,10 +8318,19 @@ namespace std {
     // [refwrap.invoke], invocation
     template<class... ArgTypes>
       constexpr invoke_result_t<T&, ArgTypes...> operator()(ArgTypes&&...) const
         noexcept(is_nothrow_invocable_v<T&, ArgTypes...>);
   };
   template<class T>
     reference_wrapper(T&) -> reference_wrapper<T>;
 }
@@ -7676,10 +8344,15 @@ function of type `T`.
 [[term.trivially.copyable.type]].
 The template parameter `T` of `reference_wrapper` may be an incomplete
 type.
 #### Constructors <a id="refwrap.const">[[refwrap.const]]</a>
 ``` cpp
 template<class U>
   constexpr reference_wrapper(U&& u) noexcept(see below);
@@ -7740,11 +8413,68 @@ template<class... ArgTypes>
 ```
 *Mandates:* `T` is a complete type.
 *Returns:* *INVOKE*(get(),
-std::forward\<ArgTypes\>(args)...). [[func.require]]
 #### Helper functions <a id="refwrap.helpers">[[refwrap.helpers]]</a>
 The template parameter `T` of the following `ref` and `cref` function
 templates may be an incomplete type.
@@ -8657,10 +9387,28 @@ is `true`.
 wrapper [[term.perfect.forwarding.call.wrapper]] `g` with call pattern
 `!invoke(fd, call_args...)`.
 *Throws:* Any exception thrown by the initialization of `fd`.
 ### Function templates `bind_front` and `bind_back` <a id="func.bind.partial">[[func.bind.partial]]</a>
 ``` cpp
 template<class F, class... Args>
   constexpr unspecified bind_front(F&& f, Args&&... args);
@@ -8706,10 +9454,48 @@ wrapper [[term.perfect.forwarding.call.wrapper]] `g` with call pattern:
   invocation.
 *Throws:* Any exception thrown by the initialization of the state
 entities of `g` [[func.def]].
 ### Function object binders <a id="func.bind">[[func.bind]]</a>
 #### General <a id="func.bind.general">[[func.bind.general]]</a>
 Subclause [[func.bind]] describes a uniform mechanism for binding
@@ -8844,13 +9630,11 @@ type `V`_`fd` is `cv FD&`.
 ``` cpp
 namespace std::placeholders {
   // M is the number of placeholders
   see below _1;
   see below _2;
-              .
-              .
-              .
   see below _M;
 }
 ```
 The number `M` of placeholders is *implementation-defined*.
@@ -8894,10 +9678,31 @@ expression [[expr.call]] of `fn`.
 #### General <a id="func.wrap.general">[[func.wrap.general]]</a>
 Subclause [[func.wrap]] describes polymorphic wrapper classes that
 encapsulate arbitrary callable objects.
 #### Class `bad_function_call` <a id="func.wrap.badcall">[[func.wrap.badcall]]</a>
 An exception of type `bad_function_call` is thrown by
 `function::operator()` [[func.wrap.func.inv]] when the function wrapper
 object has no target.
@@ -8922,12 +9727,10 @@ const char* what() const noexcept override;
 ##### General <a id="func.wrap.func.general">[[func.wrap.func.general]]</a>
 ``` cpp
 namespace std {
-  template<class> class function;       // not defined
   template<class R, class... ArgTypes>
   class function<R(ArgTypes...)> {
   public:
     using result_type = R;
@@ -8971,16 +9774,10 @@ namespace std {
 The `function` class template provides polymorphic wrappers that
 generalize the notion of a function pointer. Wrappers can store, copy,
 and call arbitrary callable objects [[func.def]], given a call signature
 [[func.def]].
-A callable type [[func.def]] `F` is *Lvalue-Callable* for argument types
-`ArgTypes` and return type `R` if the expression
-`INVOKE<R>(declval<F&>(), declval<ArgTypes>()...)`, considered as an
-unevaluated operand [[term.unevaluated.operand]], is well-formed
-[[func.require]].
 The `function` class template is a call wrapper [[func.def]] whose call
 signature [[func.def]] is `R(ArgTypes...)`.
 [*Note 1*: The types deduced by the deduction guides for `function`
 might change in future revisions of C++. — *end note*]
@@ -9002,11 +9799,11 @@ function(nullptr_t) noexcept;
 ``` cpp
 function(const function& f);
 ```
 *Ensures:* `!*this` if `!f`; otherwise, the target object of `*this` is
-a copy of `f.target()`.
 *Throws:* Nothing if `f`’s target is a specialization of
 `reference_wrapper` or a function pointer. Otherwise, may throw
 `bad_alloc` or any exception thrown by the copy constructor of the
 stored callable object.
@@ -9036,12 +9833,11 @@ template<class F> function(F&& f);
 Let `FD` be `decay_t<F>`.
 *Constraints:*
 - `is_same_v<remove_cvref_t<F>, function>` is `false`, and
-- `FD` is Lvalue-Callable [[func.wrap.func]] for argument types
-  `ArgTypes...` and return type `R`.
 *Mandates:*
 - `is_copy_constructible_v<FD>` is `true`, and
 - `is_constructible_v<FD, F>` is `true`.
@@ -9122,12 +9918,12 @@ function& operator=(nullptr_t) noexcept;
 ``` cpp
 template<class F> function& operator=(F&& f);
 ```
-*Constraints:* `decay_t<F>` is Lvalue-Callable [[func.wrap.func]] for
-argument types `ArgTypes...` and return type `R`.
 *Effects:* As if by: `function(std::forward<F>(f)).swap(*this);`
 *Returns:* `*this`.
@@ -9207,11 +10003,11 @@ template<class R, class... ArgTypes>
   void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>& f2) noexcept;
 ```
 *Effects:* As if by: `f1.swap(f2);`
-#### Move only wrapper <a id="func.wrap.move">[[func.wrap.move]]</a>
 ##### General <a id="func.wrap.move.general">[[func.wrap.move.general]]</a>
 The header provides partial specializations of `move_only_function` for
 each combination of the possible replacements of the placeholders cv,
@@ -9229,18 +10025,16 @@ above, there is a placeholder *inv-quals* defined as follows:
 ##### Class template `move_only_function` <a id="func.wrap.move.class">[[func.wrap.move.class]]</a>
 ``` cpp
 namespace std {
-  template<class... S> class move_only_function;                // not defined
   template<class R, class... ArgTypes>
   class move_only_function<R(ArgTypes...) cv ref noexcept(noex)> {
   public:
     using result_type = R;
-    // [func.wrap.move.ctor], constructors, assignment, and destructor
     move_only_function() noexcept;
     move_only_function(nullptr_t) noexcept;
     move_only_function(move_only_function&&) noexcept;
     template<class F> move_only_function(F&&);
     template<class T, class... Args>
@@ -9280,11 +10074,11 @@ dynamically allocated memory for a small contained value.
 [*Note 1*: Such small-object optimization can only be applied to a type
 `T` for which `is_nothrow_move_constructible_v<T>` is
 `true`. — *end note*]
-##### Constructors, assignment, and destructor <a id="func.wrap.move.ctor">[[func.wrap.move.ctor]]</a>
 ``` cpp
 template<class VT>
   static constexpr bool is-callable-from = see below;
 ```
@@ -9473,10 +10267,540 @@ friend void swap(move_only_function& f1, move_only_function& f2) noexcept;
 friend bool operator==(const move_only_function& f, nullptr_t) noexcept;
 ```
 *Returns:* `true` if `f` has no target object, otherwise `false`.
 ### Searchers <a id="func.search">[[func.search]]</a>
 #### General <a id="func.search.general">[[func.search.general]]</a>
 Subclause [[func.search]] provides function object types
@@ -9588,11 +10912,11 @@ boyer_moore_searcher(RandomAccessIterator1 pat_first,
                      Hash hf = Hash(),
                      BinaryPredicate pred = BinaryPredicate());
 ```
 *Preconditions:* The value type of `RandomAccessIterator1` meets the
-*Cpp17DefaultConstructible*, the *Cpp17CopyConstructible*, and the
 *Cpp17CopyAssignable* requirements.
 Let `V` be `iterator_traits<RandomAccessIterator1>::value_type`. For any
 two values `A` and `B` of type `V`, if `pred(A, B) == true`, then
 `hf(A) == hf(B)` is `true`.
@@ -9755,2651 +11079,10 @@ An enabled specialization `hash<Key>` will:
 - meet the requirement that the expression `h(k)`, where `h` is an
   object of type `hash<Key>` and `k` is an object of type `Key`, shall
   not throw an exception unless `hash<Key>` is a program-defined
   specialization.
-## Class `type_index` <a id="type.index">[[type.index]]</a>
-### Header `<typeindex>` synopsis <a id="type.index.synopsis">[[type.index.synopsis]]</a>
-``` cpp
-#include <compare>              // see [compare.syn]
-namespace std {
-  class type_index;
-  template<class T> struct hash;
-  template<> struct hash<type_index>;
-}
-```
-### `type_index` overview <a id="type.index.overview">[[type.index.overview]]</a>
-``` cpp
-namespace std {
-  class type_index {
-  public:
-    type_index(const type_info& rhs) 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;
-    bool operator>=(const type_index& rhs) const noexcept;
-    strong_ordering 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.
-  };
-}
-```
-The class `type_index` provides a simple wrapper for `type_info` which
-can be used as an index type in associative containers [[associative]]
-and in unordered associative containers [[unord]].
-### `type_index` members <a id="type.index.members">[[type.index.members]]</a>
-``` cpp
-type_index(const type_info& rhs) noexcept;
-```
-*Effects:* Constructs a `type_index` object, the equivalent of
-`target = &rhs`.
-``` cpp
-bool operator==(const type_index& rhs) const noexcept;
-```
-*Returns:* `*target == *rhs.target`.
-``` cpp
-bool operator<(const type_index& rhs) const noexcept;
-```
-*Returns:* `target->before(*rhs.target)`.
-``` cpp
-bool operator>(const type_index& rhs) const noexcept;
-```
-*Returns:* `rhs.target->before(*target)`.
-``` cpp
-bool operator<=(const type_index& rhs) const noexcept;
-```
-*Returns:* `!rhs.target->before(*target)`.
-``` cpp
-bool operator>=(const type_index& rhs) const noexcept;
-```
-*Returns:* `!target->before(*rhs.target)`.
-``` cpp
-strong_ordering operator<=>(const type_index& rhs) const noexcept;
-```
-*Effects:* Equivalent to:
-``` cpp
-if (*target == *rhs.target) return strong_ordering::equal;
-if (target->before(*rhs.target)) return strong_ordering::less;
-return strong_ordering::greater;
-```
-``` 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>;
-```
-For an object `index` of type `type_index`, `hash<type_index>()(index)`
-shall evaluate to the same result as `index.hash_code()`.
-## Execution policies <a id="execpol">[[execpol]]</a>
-### In general <a id="execpol.general">[[execpol.general]]</a>
-Subclause  [[execpol]] describes classes that are *execution policy*
-types. An object of an execution policy type indicates the kinds of
-parallelism allowed in the execution of an algorithm and expresses the
-consequent requirements on the element access functions.
-[*Example 1*:
-``` cpp
-using namespace std;
-vector<int> v = ...;
-// standard sequential sort
-sort(v.begin(), v.end());
-// explicitly sequential sort
-sort(execution::seq, v.begin(), v.end());
-// permitting parallel execution
-sort(execution::par, v.begin(), v.end());
-// permitting vectorization as well
-sort(execution::par_unseq, v.begin(), v.end());
-```
-— *end example*]
-[*Note 1*: Implementations can provide additional execution policies to
-those described in this standard as extensions to address parallel
-architectures that require idiosyncratic parameters for efficient
-execution. — *end note*]
-### Header `<execution>` synopsis <a id="execution.syn">[[execution.syn]]</a>
-``` cpp
-namespace std {
-  // [execpol.type], execution policy type trait
-  template<class T> struct is_execution_policy;
-  template<class T> constexpr bool is_execution_policy_v = is_execution_policy<T>::value;
-}
-namespace std::execution {
-  // [execpol.seq], sequenced execution policy
-  class sequenced_policy;
-  // [execpol.par], parallel execution policy
-  class parallel_policy;
-  // [execpol.parunseq], parallel and unsequenced execution policy
-  class parallel_unsequenced_policy;
-  // [execpol.unseq], unsequenced execution policy
-  class unsequenced_policy;
-  // [execpol.objects], execution policy objects
-  inline constexpr sequenced_policy            seq{ unspecified };
-  inline constexpr parallel_policy             par{ unspecified };
-  inline constexpr parallel_unsequenced_policy par_unseq{ unspecified };
-  inline constexpr unsequenced_policy          unseq{ unspecified };
-}
-```
-### Execution policy type trait <a id="execpol.type">[[execpol.type]]</a>
-``` cpp
-template<class T> struct is_execution_policy { see below };
-```
-`is_execution_policy` can be used to detect execution policies for the
-purpose of excluding function signatures from otherwise ambiguous
-overload resolution participation.
-`is_execution_policy<T>` is a *Cpp17UnaryTypeTrait* with a base
-characteristic of `true_type` if `T` is the type of a standard or
-*implementation-defined* execution policy, otherwise `false_type`.
-[*Note 1*: This provision reserves the privilege of creating
-non-standard execution policies to the library
-implementation. — *end note*]
-The behavior of a program that adds specializations for
-`is_execution_policy` is undefined.
-### Sequenced execution policy <a id="execpol.seq">[[execpol.seq]]</a>
-``` cpp
-class execution::sequenced_policy { unspecified };
-```
-The class `execution::sequenced_policy` is an execution policy type used
-as a unique type to disambiguate parallel algorithm overloading and
-require that a parallel algorithm’s execution may not be parallelized.
-During the execution of a parallel algorithm with the
-`execution::sequenced_policy` policy, if the invocation of an element
-access function exits via an exception, `terminate` is
-invoked [[except.terminate]].
-### Parallel execution policy <a id="execpol.par">[[execpol.par]]</a>
-``` cpp
-class execution::parallel_policy { unspecified };
-```
-The class `execution::parallel_policy` is an execution policy type used
-as a unique type to disambiguate parallel algorithm overloading and
-indicate that a parallel algorithm’s execution may be parallelized.
-During the execution of a parallel algorithm with the
-`execution::parallel_policy` policy, if the invocation of an element
-access function exits via an exception, `terminate` is
-invoked [[except.terminate]].
-### Parallel and unsequenced execution policy <a id="execpol.parunseq">[[execpol.parunseq]]</a>
-``` cpp
-class execution::parallel_unsequenced_policy { unspecified };
-```
-The class `execution::parallel_unsequenced_policy` is an execution
-policy type used as a unique type to disambiguate parallel algorithm
-overloading and indicate that a parallel algorithm’s execution may be
-parallelized and vectorized.
-During the execution of a parallel algorithm with the
-`execution::parallel_unsequenced_policy` policy, if the invocation of an
-element access function exits via an exception, `terminate` is
-invoked [[except.terminate]].
-### Unsequenced execution policy <a id="execpol.unseq">[[execpol.unseq]]</a>
-``` cpp
-class execution::unsequenced_policy { unspecified };
-```
-The class `unsequenced_policy` is an execution policy type used as a
-unique type to disambiguate parallel algorithm overloading and indicate
-that a parallel algorithm’s execution may be vectorized, e.g., executed
-on a single thread using instructions that operate on multiple data
-items.
-During the execution of a parallel algorithm with the
-`execution::unsequenced_policy` policy, if the invocation of an element
-access function exits via an exception, `terminate` is invoked
-[[except.terminate]].
-### Execution policy objects <a id="execpol.objects">[[execpol.objects]]</a>
-``` cpp
-inline constexpr execution::sequenced_policy            execution::seq{ unspecified };
-inline constexpr execution::parallel_policy             execution::par{ unspecified };
-inline constexpr execution::parallel_unsequenced_policy execution::par_unseq{ unspecified };
-inline constexpr execution::unsequenced_policy          execution::unseq{ unspecified };
-```
-The header `<execution>` declares global objects associated with each
-type of execution policy.
-## Primitive numeric conversions <a id="charconv">[[charconv]]</a>
-### Header `<charconv>` synopsis <a id="charconv.syn">[[charconv.syn]]</a>
-When a function is specified with a type placeholder of `integer-type`,
-the implementation provides overloads for all cv-unqualified signed and
-unsigned integer types and `char` in lieu of `integer-type`. When a
-function is specified with a type placeholder of `floating-point-type`,
-the implementation provides overloads for all cv-unqualified
-floating-point types [[basic.fundamental]] in lieu of
-`floating-point-type`.
-``` cpp
-%
-%
-{chars_format{chars_format{chars_format{chars_formatnamespace std {
-  // floating-point format for primitive numerical conversion
-  enum class chars_format {
-    scientific = unspecified,
-    fixed = unspecified,
-    hex = unspecified,
-    general = fixed | scientific
-  };
-%
-%
-{to_chars_result{to_chars_result}
-  // [charconv.to.chars], primitive numerical output conversion
-  struct to_chars_result {
-    char* ptr;
-    errc ec;
-    friend bool operator==(const to_chars_result&, const to_chars_result&) = default;
-  };
-  constexpr to_chars_result to_chars(char* first, char* last, integer-type value, int base = 10);
-  to_chars_result to_chars(char* first, char* last, bool value, int base = 10) = delete;
-  to_chars_result to_chars(char* first, char* last, floating-point-type value);
-  to_chars_result to_chars(char* first, char* last, floating-point-type value, chars_format fmt);
-  to_chars_result to_chars(char* first, char* last, floating-point-type value,
-                           chars_format fmt, int precision);
-%
-%
-{from_chars_result{from_chars_result}
-  // [charconv.from.chars], primitive numerical input conversion
-  struct from_chars_result {
-    const char* ptr;
-    errc ec;
-    friend bool operator==(const from_chars_result&, const from_chars_result&) = default;
-  };
-  constexpr from_chars_result from_chars(const char* first, const char* last,
-                                         integer-type& value, int base = 10);
-  from_chars_result from_chars(const char* first, const char* last, floating-point-type& value,
-                               chars_format fmt = chars_format::general);
-}
-```
-The type `chars_format` is a bitmask type [[bitmask.types]] with
-elements `scientific`, `fixed`, and `hex`.
-The types `to_chars_result` and `from_chars_result` have the data
-members and special members specified above. They have no base classes
-or members other than those specified.
-### Primitive numeric output conversion <a id="charconv.to.chars">[[charconv.to.chars]]</a>
-All functions named `to_chars` convert `value` into a character string
-by successively filling the range \[`first`, `last`), where \[`first`,
-`last`) is required to be a valid range. If the member `ec` of the
-return value is such that the value is equal to the value of a
-value-initialized `errc`, the conversion was successful and the member
-`ptr` is the one-past-the-end pointer of the characters written.
-Otherwise, the member `ec` has the value `errc::value_too_large`, the
-member `ptr` has the value `last`, and the contents of the range
-\[`first`, `last`) are unspecified.
-The functions that take a floating-point `value` but not a `precision`
-parameter ensure that the string representation consists of the smallest
-number of characters such that there is at least one digit before the
-radix point (if present) and parsing the representation using the
-corresponding `from_chars` function recovers `value` exactly.
-[*Note 1*: This guarantee applies only if `to_chars` and `from_chars`
-are executed on the same implementation. — *end note*]
-If there are several such representations, the representation with the
-smallest difference from the floating-point argument value is chosen,
-resolving any remaining ties using rounding according to
-`round_to_nearest` [[round.style]].
-The functions taking a `chars_format` parameter determine the conversion
-specifier for `printf` as follows: The conversion specifier is `f` if
-`fmt` is `chars_format::fixed`, `e` if `fmt` is
-`chars_format::scientific`, `a` (without leading `"0x"` in the result)
-if `fmt` is `chars_format::hex`, and `g` if `fmt` is
-`chars_format::general`.
-``` cpp
-constexpr to_chars_result to_chars(char* first, char* last, integer-type value, int base = 10);
-```
-*Preconditions:* `base` has a value between 2 and 36 (inclusive).
-*Effects:* The value of `value` is converted to a string of digits in
-the given base (with no redundant leading zeroes). Digits in the range
-10..35 (inclusive) are represented as lowercase characters `a`..`z`. If
-`value` is less than zero, the representation starts with `’-’`.
-*Throws:* Nothing.
-``` cpp
-to_chars_result to_chars(char* first, char* last, floating-point-type value);
-```
-*Effects:* `value` is converted to a string in the style of `printf` in
-the `"C"` locale. The conversion specifier is `f` or `e`, chosen
-according to the requirement for a shortest representation (see above);
-a tie is resolved in favor of `f`.
-*Throws:* Nothing.
-``` cpp
-to_chars_result to_chars(char* first, char* last, floating-point-type value, chars_format fmt);
-```
-*Preconditions:* `fmt` has the value of one of the enumerators of
-`chars_format`.
-*Effects:* `value` is converted to a string in the style of `printf` in
-the `"C"` locale.
-*Throws:* Nothing.
-``` cpp
-to_chars_result to_chars(char* first, char* last, floating-point-type value,
-                         chars_format fmt, int precision);
-```
-*Preconditions:* `fmt` has the value of one of the enumerators of
-`chars_format`.
-*Effects:* `value` is converted to a string in the style of `printf` in
-the `"C"` locale with the given precision.
-*Throws:* Nothing.
-See also: ISO C 7.21.6.1
-### Primitive numeric input conversion <a id="charconv.from.chars">[[charconv.from.chars]]</a>
-All functions named `from_chars` analyze the string \[`first`, `last`)
-for a pattern, where \[`first`, `last`) is required to be a valid range.
-If no characters match the pattern, `value` is unmodified, the member
-`ptr` of the return value is `first` and the member `ec` is equal to
-`errc::invalid_argument`.
-[*Note 1*: If the pattern allows for an optional sign, but the string
-has no digit characters following the sign, no characters match the
-pattern. — *end note*]
-Otherwise, the characters matching the pattern are interpreted as a
-representation of a value of the type of `value`. The member `ptr` of
-the return value points to the first character not matching the pattern,
-or has the value `last` if all characters match. If the parsed value is
-not in the range representable by the type of `value`, `value` is
-unmodified and the member `ec` of the return value is equal to
-`errc::result_out_of_range`. Otherwise, `value` is set to the parsed
-value, after rounding according to `round_to_nearest` [[round.style]],
-and the member `ec` is value-initialized.
-``` cpp
-constexpr from_chars_result from_chars(const char* first, const char* last,
-                                       integer-type& value, int base = 10);
-```
-*Preconditions:* `base` has a value between 2 and 36 (inclusive).
-*Effects:* The pattern is the expected form of the subject sequence in
-the `"C"` locale for the given nonzero base, as described for `strtol`,
-except that no `"0x"` or `"0X"` prefix shall appear if the value of
-`base` is 16, and except that `’-’` is the only sign that may appear,
-and only if `value` has a signed type.
-*Throws:* Nothing.
-``` cpp
-from_chars_result from_chars(const char* first, const char* last, floating-point-type& value,
-                             chars_format fmt = chars_format::general);
-```
-*Preconditions:* `fmt` has the value of one of the enumerators of
-`chars_format`.
-*Effects:* The pattern is the expected form of the subject sequence in
-the `"C"` locale, as described for `strtod`, except that
-- the sign `’+’` may only appear in the exponent part;
-- if `fmt` has `chars_format::scientific` set but not
-  `chars_format::fixed`, the otherwise optional exponent part shall
-  appear;
-- if `fmt` has `chars_format::fixed` set but not
-  `chars_format::scientific`, the optional exponent part shall not
-  appear; and
-- if `fmt` is `chars_format::hex`, the prefix `"0x"` or `"0X"` is
-  assumed. \[*Example 1*: The string `0x123` is parsed to have the value
-  `0` with remaining characters `x123`. — *end example*]
-In any case, the resulting `value` is one of at most two floating-point
-values closest to the value of the string matching the pattern.
-*Throws:* Nothing.
-See also: ISO C 7.22.1.3, 7.22.1.4
-## Formatting <a id="format">[[format]]</a>
-### Header `<format>` synopsis <a id="format.syn">[[format.syn]]</a>
-``` cpp
-namespace std {
-  // [format.context], class template basic_format_context
-  template<class Out, class charT> class basic_format_context;
-  using format_context = basic_format_context<unspecified, char>;
-  using wformat_context = basic_format_context<unspecified, wchar_t>;
-  // [format.args], class template basic_format_args
-  template<class Context> class basic_format_args;
-  using format_args = basic_format_args<format_context>;
-  using wformat_args = basic_format_args<wformat_context>;
-  // [format.fmt.string], class template basic_format_string
-  template<class charT, class... Args>
-    struct basic_format_string;
-  template<class... Args>
-    using format_string = basic_format_string<char, type_identity_t<Args>...>;
-  template<class... Args>
-    using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
-  // [format.functions], formatting functions
-  template<class... Args>
-    string format(format_string<Args...> fmt, Args&&... args);
-  template<class... Args>
-    wstring format(wformat_string<Args...> fmt, Args&&... args);
-  template<class... Args>
-    string format(const locale& loc, format_string<Args...> fmt, Args&&... args);
-  template<class... Args>
-    wstring format(const locale& loc, wformat_string<Args...> fmt, Args&&... args);
-  string vformat(string_view fmt, format_args args);
-  wstring vformat(wstring_view fmt, wformat_args args);
-  string vformat(const locale& loc, string_view fmt, format_args args);
-  wstring vformat(const locale& loc, wstring_view fmt, wformat_args args);
-  template<class Out, class... Args>
-    Out format_to(Out out, format_string<Args...> fmt, Args&&... args);
-  template<class Out, class... Args>
-    Out format_to(Out out, wformat_string<Args...> fmt, Args&&... args);
-  template<class Out, class... Args>
-    Out format_to(Out out, const locale& loc, format_string<Args...> fmt, Args&&... args);
-  template<class Out, class... Args>
-    Out format_to(Out out, const locale& loc, wformat_string<Args...> fmt, Args&&... args);
-  template<class Out>
-    Out vformat_to(Out out, string_view fmt, format_args args);
-  template<class Out>
-    Out vformat_to(Out out, wstring_view fmt, wformat_args args);
-  template<class Out>
-    Out vformat_to(Out out, const locale& loc, string_view fmt, format_args args);
-  template<class Out>
-    Out vformat_to(Out out, const locale& loc, wstring_view fmt, wformat_args args);
-  template<class Out> struct format_to_n_result {
-    Out out;
-    iter_difference_t<Out> size;
-  };
-  template<class Out, class... Args>
-    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
-                                        format_string<Args...> fmt, Args&&... args);
-  template<class Out, class... Args>
-    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
-                                        wformat_string<Args...> fmt, Args&&... args);
-  template<class Out, class... Args>
-    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
-                                        const locale& loc, format_string<Args...> fmt,
-                                        Args&&... args);
-  template<class Out, class... Args>
-    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
-                                        const locale& loc, wformat_string<Args...> fmt,
-                                        Args&&... args);
-  template<class... Args>
-    size_t formatted_size(format_string<Args...> fmt, Args&&... args);
-  template<class... Args>
-    size_t formatted_size(wformat_string<Args...> fmt, Args&&... args);
-  template<class... Args>
-    size_t formatted_size(const locale& loc, format_string<Args...> fmt, Args&&... args);
-  template<class... Args>
-    size_t formatted_size(const locale& loc, wformat_string<Args...> fmt, Args&&... args);
-  // [format.formatter], formatter
-  template<class T, class charT = char> struct formatter;
-  // [format.formattable], concept formattable
-  template<class T, class charT>
-    concept formattable = see below;
-  template<class R, class charT>
-    concept const-formattable-range =                                   // exposition only
-      ranges::input_range<const R> &&
-      formattable<ranges::range_reference_t<const R>, charT>;
-  template<class R, class charT>
-    using fmt-maybe-const =                                             // exposition only
-      conditional_t<const-formattable-range<R, charT>, const R, R>;
-  // [format.parse.ctx], class template basic_format_parse_context
-  template<class charT> class basic_format_parse_context;
-  using format_parse_context = basic_format_parse_context<char>;
-  using wformat_parse_context = basic_format_parse_context<wchar_t>;
-  // [format.range], formatting of ranges
-  // [format.range.fmtkind], variable template format_kind
-  enum class range_format {
-    disabled,
-    map,
-    set,
-    sequence,
-    string,
-    debug_string
-  };
-  template<class R>
-    constexpr unspecified format_kind = unspecified;
-  template<ranges::input_range R>
-      requires same_as<R, remove_cvref_t<R>>
-    constexpr range_format format_kind<R> = see below;
-  // [format.range.formatter], class template range_formatter
-  template<class T, class charT = char>
-    requires same_as<remove_cvref_t<T>, T> && formattable<T, charT>
-  class range_formatter;
-  // [format.range.fmtdef], class template range-default-formatter
-  template<range_format K, ranges::input_range R, class charT>
-    struct range-default-formatter;                                     // exposition only
-  // [format.range.fmtmap], [format.range.fmtset], [format.range.fmtstr], specializations for maps, sets, and strings
-  template<ranges::input_range R, class charT>
-    requires (format_kind<R> != range_format::disabled) &&
-             formattable<ranges::range_reference_t<R>, charT>
-  struct formatter<R, charT> : range-default-formatter<format_kind<R>, R, charT> { };
-  // [format.arguments], arguments
-  // [format.arg], class template basic_format_arg
-  template<class Context> class basic_format_arg;
-  template<class Visitor, class Context>
-    decltype(auto) visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
-  // [format.arg.store], class template format-arg-store
-  template<class Context, class... Args> class format-arg-store;        // exposition only
-  template<class Context = format_context, class... Args>
-    format-arg-store<Context, Args...>
-      make_format_args(Args&&... fmt_args);
-  template<class... Args>
-    format-arg-store<wformat_context, Args...>
-      make_wformat_args(Args&&... args);
-  // [format.error], class format_error
-  class format_error;
-}
-```
-The class template `format_to_n_result` has the template parameters,
-data members, and special members specified above. It has no base
-classes or members other than those specified.
-### Format string <a id="format.string">[[format.string]]</a>
-#### In general <a id="format.string.general">[[format.string.general]]</a>
-A *format string* for arguments `args` is a (possibly empty) sequence of
-*replacement fields*, *escape sequences*, and characters other than `{`
-and `}`. Let `charT` be the character type of the format string. Each
-character that is not part of a replacement field or an escape sequence
-is copied unchanged to the output. An escape sequence is one of `{{` or
-`}}`. It is replaced with `{` or `}`, respectively, in the output. The
-syntax of replacement fields is as follows:
-``` bnf
-replacement-field
-    '{' arg-idₒₚₜ format-specifierₒₚₜ '}'
-```
-``` bnf
-arg-id
-    '0'
-    positive-integer
-```
-``` bnf
-positive-integer
-    nonzero-digit
-    positive-integer digit
-```
-``` bnf
-nonnegative-integer
-    digit
-    nonnegative-integer digit
-```
-``` bnf
-nonzero-digit one of
-    '1 2 3 4 5 6 7 8 9'
-```
-``` bnf
-digit one of
-    '0 1 2 3 4 5 6 7 8 9'
-```
-``` bnf
-format-specifier
-    ':' format-spec
-```
-``` bnf
-format-spec
-    as specified by the formatter specialization for the argument type
-```
-The *arg-id* field specifies the index of the argument in `args` whose
-value is to be formatted and inserted into the output instead of the
-replacement field. If there is no argument with the index *arg-id* in
-`args`, the string is not a format string for `args`. The optional
-*format-specifier* field explicitly specifies a format for the
-replacement value.
-[*Example 1*:
-``` cpp
-string s = format("{0}-{{", 8);         // value of s is "8-{"
-```
-— *end example*]
-If all *arg-id*s in a format string are omitted (including those in the
-*format-spec*, as interpreted by the corresponding `formatter`
-specialization), argument indices 0, 1, 2, … will automatically be used
-in that order. If some *arg-id*s are omitted and some are present, the
-string is not a format string.
-[*Note 1*: A format string cannot contain a mixture of automatic and
-manual indexing. — *end note*]
-[*Example 2*:
-``` cpp
-string s0 = format("{} to {}",   "a", "b"); // OK, automatic indexing
-string s1 = format("{1} to {0}", "a", "b"); // OK, manual indexing
-string s2 = format("{0} to {}",  "a", "b"); // not a format string (mixing automatic and manual indexing),
-                                            // ill-formed
-string s3 = format("{} to {1}",  "a", "b"); // not a format string (mixing automatic and manual indexing),
-                                            // ill-formed
-```
-— *end example*]
-The *format-spec* field contains *format specifications* that define how
-the value should be presented. Each type can define its own
-interpretation of the *format-spec* field. If *format-spec* does not
-conform to the format specifications for the argument type referred to
-by *arg-id*, the string is not a format string for `args`.
-[*Example 3*:
-- For arithmetic, pointer, and string types the *format-spec* is
-  interpreted as a *std-format-spec* as described in
-  [[format.string.std]].
-- For chrono types the *format-spec* is interpreted as a
-  *chrono-format-spec* as described in [[time.format]].
-- For user-defined `formatter` specializations, the behavior of the
-  `parse` member function determines how the *format-spec* is
-  interpreted.
-— *end example*]
-#### Standard format specifiers <a id="format.string.std">[[format.string.std]]</a>
-Each `formatter` specialization described in [[format.formatter.spec]]
-for fundamental and string types interprets *format-spec* as a
-*std-format-spec*.
-[*Note 1*: The format specification can be used to specify such details
-as minimum field width, alignment, padding, and decimal precision. Some
-of the formatting options are only supported for arithmetic
-types. — *end note*]
-The syntax of format specifications is as follows:
-``` bnf
-std-format-spec
-    fill-and-alignₒₚₜ signₒₚₜ '#'ₒₚₜ '0'ₒₚₜ widthₒₚₜ precisionₒₚₜ 'L'ₒₚₜ typeₒₚₜ
-```
-``` bnf
-fill-and-align
-    fillₒₚₜ align
-```
-``` bnf
-fill
-    any character other than \{ or \}
-```
-``` bnf
-align one of
-    '< > ^'
-```
-``` bnf
-sign one of
-    '+ -' space
-```
-``` bnf
-width
-    positive-integer
-    '{' arg-idₒₚₜ '}'
-```
-``` bnf
-precision
-    '.' nonnegative-integer
-    '.' '{' arg-idₒₚₜ '}'
-```
-``` bnf
-type one of
-    'a A b B c d e E f F g G o p s x X ?'
-```
-Field widths are specified in *field width units*; the number of column
-positions required to display a sequence of characters in a terminal.
-The *minimum field width* is the number of field width units a
-replacement field minimally requires of the formatted sequence of
-characters produced for a format argument. The *estimated field width*
-is the number of field width units that are required for the formatted
-sequence of characters produced for a format argument independent of the
-effects of the *width* option. The *padding width* is the greater of `0`
-and the difference of the minimum field width and the estimated field
-width.
-[*Note 2*: The POSIX `wcswidth` function is an example of a function
-that, given a string, returns the number of column positions required by
-a terminal to display the string. — *end note*]
-The *fill character* is the character denoted by the *fill* option or,
-if the *fill* option is absent, the space character. For a format
-specification in UTF-8, UTF-16, or UTF-32, the fill character
-corresponds to a single Unicode scalar value.
-[*Note 3*: The presence of a *fill* option is signaled by the character
-following it, which must be one of the alignment options. If the second
-character of *std-format-spec* is not a valid alignment option, then it
-is assumed that the *fill* and *align* options are both
-absent. — *end note*]
-The *align* option applies to all argument types. The meaning of the
-various alignment options is as specified in [[format.align]].
-[*Example 1*:
-``` cpp
-char c = 120;
-string s0 = format("{:6}", 42);             // value of s0 is "\ \ \ \ 42"
-string s1 = format("{:6}", 'x');            // value of s1 is "x\ \ \ \ \ "
-string s2 = format("{:*<6}", 'x');          // value of s2 is "x*****"
-string s3 = format("{:*>6}", 'x');          // value of s3 is "*****x"
-string s4 = format("{:*^6}", 'x');          // value of s4 is "**x***"
-string s5 = format("{:6d}", c);             // value of s5 is "\ \ \ 120"
-string s6 = format("{:6}", true);           // value of s6 is "true\ \ "
-string s7 = format("{:*<6.3}", "123456");   // value of s7 is "123***"
-string s8 = format("{:02}", 1234);          // value of s8 is "1234"
-string s9 = format("{:*<}", "12");          // value of s9 is "12"
-string sA = format("{:*<6}", "12345678");   // value of sA is "12345678"
-```
-— *end example*]
-[*Note 4*: The *fill*, *align*, and `0` options have no effect when the
-minimum field width is not greater than the estimated field width
-because padding width is `0` in that case. Since fill characters are
-assumed to have a field width of `1`, use of a character with a
-different field width can produce misaligned output. The
-U+1f921 (clown face) character has a field width of `2`. The examples
-above that include that character illustrate the effect of the field
-width when that character is used as a fill character as opposed to when
-it is used as a formatting argument. — *end note*]
-**Table: Meaning of align options** <a id="format.align">[format.align]</a>
-| Option | Meaning                                                                                                                                                                                                                                                                                                      |
-| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `<`    | Forces the formatted argument to be aligned to the start of the field by inserting $n$ fill characters after the formatted argument where $n$ is the padding width. This is the default for non-arithmetic non-pointer types, `charT`, and `bool`, unless an integer presentation type is specified.         |
-| % `>`  | Forces the formatted argument to be aligned to the end of the field by inserting $n$ fill characters before the formatted argument where $n$ is the padding width. This is the default for arithmetic types other than `charT` and `bool`, pointer types, or when an integer presentation type is specified. |
-| % `^`  | Forces the formatted argument to be centered within the field by inserting $\bigl\lfloor \frac{n}{2} \bigr\rfloor$ fill characters before and $\bigl\lceil \frac{n}{2} \bigr\rceil$ fill characters after the formatted argument, where $n$ is the padding width.                                            |
-The *sign* option is only valid for arithmetic types other than `charT`
-and `bool` or when an integer presentation type is specified. The
-meaning of the various options is as specified in [[format.sign]].
-**Table: Meaning of sign options** <a id="format.sign">[format.sign]</a>
-| Option  | Meaning                                                                                                                                                                                                                                                                                                                                    |
-| ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `+`     | Indicates that a sign should be used for both non-negative and negative numbers. The `+` sign is inserted before the output of `to_chars` for non-negative numbers other than negative zero. *For negative numbers and negative zero the output of `to_chars` will already contain the sign so no additional transformation is performed.* |
-| % `-`   | Indicates that a sign should be used for negative numbers and negative zero only (this is the default behavior).                                                                                                                                                                                                                           |
-| % space | Indicates that a leading space should be used for non-negative numbers other than negative zero, and a minus sign for negative numbers and negative zero.                                                                                                                                                                                  |
-The *sign* option applies to floating-point infinity and NaN.
-[*Example 2*:
-``` cpp
-double inf = numeric_limits<double>::infinity();
-double nan = numeric_limits<double>::quiet_NaN();
-string s0 = format("{0:},{0:+},{0:-},{0: }", 1);        // value of s0 is "1,+1,1, 1"
-string s1 = format("{0:},{0:+},{0:-},{0: }", -1);       // value of s1 is "-1,-1,-1,-1"
-string s2 = format("{0:},{0:+},{0:-},{0: }", inf);      // value of s2 is "inf,+inf,inf, inf"
-string s3 = format("{0:},{0:+},{0:-},{0: }", nan);      // value of s3 is "nan,+nan,nan, nan"
-```
-— *end example*]
-The `#` option causes the *alternate form* to be used for the
-conversion. This option is valid for arithmetic types other than `charT`
-and `bool` or when an integer presentation type is specified, and not
-otherwise. For integral types, the alternate form inserts the base
-prefix (if any) specified in [[format.type.int]] into the output after
-the sign character (possibly space) if there is one, or before the
-output of `to_chars` otherwise. For floating-point types, the alternate
-form causes the result of the conversion of finite values to always
-contain a decimal-point character, even if no digits follow it.
-Normally, a decimal-point character appears in the result of these
-conversions only if a digit follows it. In addition, for `g` and `G`
-conversions, trailing zeros are not removed from the result.
-The `0` option is valid for arithmetic types other than `charT` and
-`bool` or when an integer presentation type is specified. For formatting
-arguments that have a value other than an infinity or a NaN, this option
-pads the formatted argument by inserting the `0` character n times
-following the sign or base prefix indicators (if any) where n is `0` if
-the *align* option is present and is the padding width otherwise.
-[*Example 3*:
-``` cpp
-char c = 120;
-string s1 = format("{:+06d}", c);       // value of s1 is "+00120"
-string s2 = format("{:#06x}", 0xa);     // value of s2 is "0x000a"
-string s3 = format("{:<06}", -42);      // value of s3 is "-42\ \ \ " (0 has no effect)
-string s4 = format("{:06}", inf);       // value of s4 is "\ \ \ inf" (0 has no effect)
-```
-— *end example*]
-The *width* option specifies the minimum field width. If the *width*
-option is absent, the minimum field width is `0`.
-If `{ \opt{arg-id} }` is used in a *width* or *precision* option, the
-value of the corresponding formatting argument is used as the value of
-the option. If the corresponding formatting argument is not of standard
-signed or unsigned integer type, or its value is negative, an exception
-of type `format_error` is thrown.
-If *positive-integer* is used in a *width* option, the value of the
-*positive-integer* is interpreted as a decimal integer and used as the
-value of the option.
-For the purposes of width computation, a string is assumed to be in a
-locale-independent, *implementation-defined* encoding. Implementations
-should use either UTF-8, UTF-16, or UTF-32, on platforms capable of
-displaying Unicode text in a terminal.
-[*Note 5*:
-This is the case for Windows[^2]
--based and many POSIX-based operating systems.
-— *end note*]
-For a sequence of characters in UTF-8, UTF-16, or UTF-32, an
-implementation should use as its field width the sum of the field widths
-of the first code point of each extended grapheme cluster. Extended
-grapheme clusters are defined by UAX \#29 of the Unicode Standard. The
-following code points have a field width of 2:
-- any code point with the `East_Asian_Width="W"` or
-  `East_Asian_Width="F"` Derived Extracted Property as described by UAX
-  \#44 of the Unicode Standard
-- `U+4dc0` – `U+4dff` (Yijing Hexagram Symbols)
-- `U+1f300` – `U+1f5ff` (Miscellaneous Symbols and Pictographs)
-- `U+1f900` – `U+1f9ff` (Supplemental Symbols and Pictographs)
-The field width of all other code points is 1.
-For a sequence of characters in neither UTF-8, UTF-16, nor UTF-32, the
-field width is unspecified.
-The *precision* option is valid for floating-point and string types. For
-floating-point types, the value of this option specifies the precision
-to be used for the floating-point presentation type. For string types,
-this option specifies the longest prefix of the formatted argument to be
-included in the replacement field such that the field width of the
-prefix is no greater than the value of this option.
-If *nonnegative-integer* is used in a *precision* option, the value of
-the decimal integer is used as the value of the option.
-When the `L` option is used, the form used for the conversion is called
-the *locale-specific form*. The `L` option is only valid for arithmetic
-types, and its effect depends upon the type.
-- For integral types, the locale-specific form causes the context’s
-  locale to be used to insert the appropriate digit group separator
-  characters.
-- For floating-point types, the locale-specific form causes the
-  context’s locale to be used to insert the appropriate digit group and
-  radix separator characters.
-- For the textual representation of `bool`, the locale-specific form
-  causes the context’s locale to be used to insert the appropriate
-  string as if obtained with `numpunct::truename` or
-  `numpunct::falsename`.
-The *type* determines how the data should be presented.
-The available string presentation types are specified in
-[[format.type.string]].
-**Table: Meaning of type options for strings** <a id="format.type.string">[format.type.string]</a>
-| Type      | Meaning                                                            |
-| --------- | ------------------------------------------------------------------ |
-| none, `s` | Copies the string to the output.                                   |
-| % `?`     | Copies the escaped string [[format.string.escaped]] to the output. |
-The meaning of some non-string presentation types is defined in terms of
-a call to `to_chars`. In such cases, let \[`first`, `last`) be a range
-large enough to hold the `to_chars` output and `value` be the formatting
-argument value. Formatting is done as if by calling `to_chars` as
-specified and copying the output through the output iterator of the
-format context.
-[*Note 6*: Additional padding and adjustments are performed prior to
-copying the output through the output iterator as specified by the
-format specifiers. — *end note*]
-The available integer presentation types for integral types other than
-`bool` and `charT` are specified in [[format.type.int]].
-[*Example 4*:
-``` cpp
-string s0 = format("{}", 42);                           // value of s0 is "42"
-string s1 = format("{0:b} {0:d} {0:o} {0:x}", 42);      // value of s1 is "101010 42 52 2a"
-string s2 = format("{0:#x} {0:#X}", 42);                // value of s2 is "0x2a 0X2A"
-string s3 = format("{:L}", 1234);                       // value of s3 can be "1,234"
-                                                        // (depending on the locale)
-```
-— *end example*]
-**Table: Meaning of type options for integer types** <a id="format.type.int">[format.type.int]</a>
-| Type   | Meaning                                                                                                                                                   |
-| ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `b`    | `to_chars(first, last, value, 2)`; \indextext{base prefix}% the base prefix is `0b`.                                                                      |
-| % `B`  | The same as `b`, except that \indextext{base prefix}% the base prefix is `0B`.                                                                            |
-| % `c`  | Copies the character `static_cast<charT>(value)` to the output. Throws `format_error` if `value` is not in the range of representable values for `charT`. |
-| % `d`  | `to_chars(first, last, value)`.                                                                                                                           |
-| % `o`  | `to_chars(first, last, value, 8)`; \indextext{base prefix}% the base prefix is `0` if `value` is nonzero and is empty otherwise.                          |
-| % `x`  | `to_chars(first, last, value, 16)`; \indextext{base prefix}% the base prefix is `0x`.                                                                     |
-| % `X`  | The same as `x`, except that it uses uppercase letters for digits above 9 and \indextext{base prefix}% the base prefix is `0X`.                           |
-| % none | The same as `d`. *If the formatting argument type is `charT` or `bool`, the default is instead `c` or `s`, respectively.*                                 |
-The available `charT` presentation types are specified in
-[[format.type.char]].
-**Table: Meaning of type options for `charT`** <a id="format.type.char">[format.type.char]</a>
-| Type                           | Meaning                                                               |
-| ------------------------------ | --------------------------------------------------------------------- |
-| none, `c`                      | Copies the character to the output.                                   |
-| % `b`, `B`, `d`, `o`, `x`, `X` | As specified in [[format.type.int]].                                  |
-| % `?`                          | Copies the escaped character [[format.string.escaped]] to the output. |
-The available `bool` presentation types are specified in
-[[format.type.bool]].
-**Table: Meaning of type options for `bool`** <a id="format.type.bool">[format.type.bool]</a>
-| Type                           | Meaning                                                                                |
-| ------------------------------ | -------------------------------------------------------------------------------------- |
-| none, `s`                      | Copies textual representation, either `true` or `false`, to the output.                |
-| % `b`, `B`, `d`, `o`, `x`, `X` | As specified in [[format.type.int]] for the value `static_cast<unsigned char>(value)`. |
-The available floating-point presentation types and their meanings for
-values other than infinity and NaN are specified in
-[[format.type.float]]. For lower-case presentation types, infinity and
-NaN are formatted as `inf` and `nan`, respectively. For upper-case
-presentation types, infinity and NaN are formatted as `INF` and `NAN`,
-respectively.
-[*Note 7*: In either case, a sign is included if indicated by the
-*sign* option. — *end note*]
-**Table: Meaning of type options for floating-point types** <a id="format.type.float">[format.type.float]</a>
-| Type       | Meaning                                                                                                                                                                                                                                                                                                   |
-| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `a`        | If precision is specified, equivalent to \begin{codeblock} to_chars(first, last, value, chars_format::hex, precision) \end{codeblock} where `precision` is the specified formatting precision; equivalent to \begin{codeblock} to_chars(first, last, value, chars_format::hex) \end{codeblock} otherwise. |
-| % `A`      | The same as `a`, except that it uses uppercase letters for digits above 9 and `P` to indicate the exponent.                                                                                                                                                                                               |
-| % `e`      | Equivalent to \begin{codeblock} to_chars(first, last, value, chars_format::scientific, precision) \end{codeblock} where `precision` is the specified formatting precision, or `6` if precision is not specified.                                                                                          |
-| % `E`      | The same as `e`, except that it uses `E` to indicate exponent.                                                                                                                                                                                                                                            |
-| % `f`, `F` | Equivalent to \begin{codeblock} to_chars(first, last, value, chars_format::fixed, precision) \end{codeblock} where `precision` is the specified formatting precision, or `6` if precision is not specified.                                                                                               |
-| % `g`      | Equivalent to \begin{codeblock} to_chars(first, last, value, chars_format::general, precision) \end{codeblock} where `precision` is the specified formatting precision, or `6` if precision is not specified.                                                                                             |
-| % `G`      | The same as `g`, except that it uses `E` to indicate exponent.                                                                                                                                                                                                                                            |
-| % none     | If precision is specified, equivalent to \begin{codeblock} to_chars(first, last, value, chars_format::general, precision) \end{codeblock} where `precision` is the specified formatting precision; equivalent to \begin{codeblock} to_chars(first, last, value) \end{codeblock} otherwise.                |
-The available pointer presentation types and their mapping to `to_chars`
-are specified in [[format.type.ptr]].
-[*Note 8*: Pointer presentation types also apply to
-`nullptr_t`. — *end note*]
-**Table: Meaning of type options for pointer types** <a id="format.type.ptr">[format.type.ptr]</a>
-| Type      | Meaning                                                                                                                                                                                                                                  |
-| --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| none, `p` | If `uintptr_t` is defined, \begin{codeblock} to_chars(first, last, reinterpret_cast<uintptr_t>(value), 16) \end{codeblock} with the prefix `0x` inserted immediately before the output of `to_chars`; otherwise, implementation-defined. |
-### Error reporting <a id="format.err.report">[[format.err.report]]</a>
-Formatting functions throw `format_error` if an argument `fmt` is passed
-that is not a format string for `args`. They propagate exceptions thrown
-by operations of `formatter` specializations and iterators. Failure to
-allocate storage is reported by throwing an exception as described in
-[[res.on.exception.handling]].
-### Class template `basic_format_string` <a id="format.fmt.string">[[format.fmt.string]]</a>
-``` cpp
-namespace std {
-  template<class charT, class... Args>
-  struct basic_format_string {
-  private:
-    basic_string_view<charT> str;         // exposition only
-  public:
-    template<class T> consteval basic_format_string(const T& s);
-    constexpr basic_string_view<charT> get() const noexcept { return str; }
-  };
-}
-```
-``` cpp
-template<class T> consteval basic_format_string(const T& s);
-```
-*Constraints:* `const T&` models
-`convertible_to<basic_string_view<charT>>`.
-*Effects:* Direct-non-list-initializes *str* with `s`.
-*Remarks:* A call to this function is not a core constant
-expression [[expr.const]] unless there exist `args` of types `Args` such
-that *str* is a format string for `args`.
-### Formatting functions <a id="format.functions">[[format.functions]]</a>
-In the description of the functions, operator `+` is used for some of
-the iterator categories for which it does not have to be defined. In
-these cases the semantics of `a + n` are the same as in
-[[algorithms.requirements]].
-``` cpp
-template<class... Args>
-  string format(format_string<Args...> fmt, Args&&... args);
-```
-*Effects:* Equivalent to:
-``` cpp
-return vformat(fmt.str, make_format_args(args...));
-```
-``` cpp
-template<class... Args>
-  wstring format(wformat_string<Args...> fmt, Args&&... args);
-```
-*Effects:* Equivalent to:
-``` cpp
-return vformat(fmt.str, make_wformat_args(args...));
-```
-``` cpp
-template<class... Args>
-  string format(const locale& loc, format_string<Args...> fmt, Args&&... args);
-```
-*Effects:* Equivalent to:
-``` cpp
-return vformat(loc, fmt.str, make_format_args(args...));
-```
-``` cpp
-template<class... Args>
-  wstring format(const locale& loc, wformat_string<Args...> fmt, Args&&... args);
-```
-*Effects:* Equivalent to:
-``` cpp
-return vformat(loc, fmt.str, make_wformat_args(args...));
-```
-``` cpp
-string vformat(string_view fmt, format_args args);
-wstring vformat(wstring_view fmt, wformat_args args);
-string vformat(const locale& loc, string_view fmt, format_args args);
-wstring vformat(const locale& loc, wstring_view fmt, wformat_args args);
-```
-*Returns:* A string object holding the character representation of
-formatting arguments provided by `args` formatted according to
-specifications given in `fmt`. If present, `loc` is used for
-locale-specific formatting.
-*Throws:* As specified in  [[format.err.report]].
-``` cpp
-template<class Out, class... Args>
-  Out format_to(Out out, format_string<Args...> fmt, Args&&... args);
-```
-*Effects:* Equivalent to:
-``` cpp
-return vformat_to(std::move(out), fmt.str, make_format_args(args...));
-```
-``` cpp
-template<class Out, class... Args>
-  Out format_to(Out out, wformat_string<Args...> fmt, Args&&... args);
-```
-*Effects:* Equivalent to:
-``` cpp
-return vformat_to(std::move(out), fmt.str, make_wformat_args(args...));
-```
-``` cpp
-template<class Out, class... Args>
-  Out format_to(Out out, const locale& loc, format_string<Args...>  fmt, Args&&... args);
-```
-*Effects:* Equivalent to:
-``` cpp
-return vformat_to(std::move(out), loc, fmt.str, make_format_args(args...));
-```
-``` cpp
-template<class Out, class... Args>
-  Out format_to(Out out, const locale& loc, wformat_string<Args...> fmt, Args&&... args);
-```
-*Effects:* Equivalent to:
-``` cpp
-return vformat_to(std::move(out), loc, fmt.str, make_wformat_args(args...));
-```
-``` cpp
-template<class Out>
-  Out vformat_to(Out out, string_view fmt, format_args args);
-template<class Out>
-  Out vformat_to(Out out, wstring_view fmt, wformat_args args);
-template<class Out>
-  Out vformat_to(Out out, const locale& loc, string_view fmt, format_args args);
-template<class Out>
-  Out vformat_to(Out out, const locale& loc, wstring_view fmt, wformat_args args);
-```
-Let `charT` be `decltype(fmt)::value_type`.
-*Constraints:* `Out` satisfies `output_iterator<const charT&>`.
-*Preconditions:* `Out` models `output_iterator<const charT&>`.
-*Effects:* Places the character representation of formatting the
-arguments provided by `args`, formatted according to the specifications
-given in `fmt`, into the range \[`out`, `out + N`), where `N` is the
-number of characters in that character representation. If present, `loc`
-is used for locale-specific formatting.
-*Returns:* `out + N`.
-*Throws:* As specified in  [[format.err.report]].
-``` cpp
-template<class Out, class... Args>
-  format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
-                                      format_string<Args...> fmt, Args&&... args);
-template<class Out, class... Args>
-  format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
-                                      wformat_string<Args...> fmt, Args&&... args);
-template<class Out, class... Args>
-  format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
-                                      const locale& loc, format_string<Args...> fmt,
-                                      Args&&... args);
-template<class Out, class... Args>
-  format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
-                                      const locale& loc, wformat_string<Args...> fmt,
-                                      Args&&... args);
-```
-Let
-- `charT` be `decltype(fmt.`*`str`*`)::value_type`,
-- `N` be `formatted_size(fmt, args...)` for the functions without a
-  `loc` parameter and `formatted_size(loc, fmt, args...)` for the
-  functions with a `loc` parameter, and
-- `M` be `clamp(n, 0, N)`.
-*Constraints:* `Out` satisfies `output_iterator<const charT&>`.
-*Preconditions:* `Out` models `output_iterator<const charT&>`, and
-`formatter<``remove_cvref_t<Tᵢ``>, charT>` meets the
-requirements [[formatter.requirements]] for each `Tᵢ` in `Args`.
-*Effects:* Places the first `M` characters of the character
-representation of formatting the arguments provided by `args`, formatted
-according to the specifications given in `fmt`, into the range \[`out`,
-`out + M`). If present, `loc` is used for locale-specific formatting.
-*Returns:* `{out + M, N}`.
-*Throws:* As specified in  [[format.err.report]].
-``` cpp
-template<class... Args>
-  size_t formatted_size(format_string<Args...> fmt, Args&&... args);
-template<class... Args>
-  size_t formatted_size(wformat_string<Args...> fmt, Args&&... args);
-template<class... Args>
-  size_t formatted_size(const locale& loc, format_string<Args...> fmt, Args&&... args);
-template<class... Args>
-  size_t formatted_size(const locale& loc, wformat_string<Args...> fmt, Args&&... args);
-```
-Let `charT` be `decltype(fmt.`*`str`*`)::value_type`.
-*Preconditions:* `formatter<``remove_cvref_t<Tᵢ``>, charT>` meets the
-requirements [[formatter.requirements]] for each `Tᵢ` in `Args`.
-*Returns:* The number of characters in the character representation of
-formatting arguments `args` formatted according to specifications given
-in `fmt`. If present, `loc` is used for locale-specific formatting.
-*Throws:* As specified in  [[format.err.report]].
-### Formatter <a id="format.formatter">[[format.formatter]]</a>
-#### Formatter requirements <a id="formatter.requirements">[[formatter.requirements]]</a>
-A type `F` meets the requirements if it meets the
-- *Cpp17DefaultConstructible* ([[cpp17.defaultconstructible]]),
-- *Cpp17CopyConstructible* ([[cpp17.copyconstructible]]),
-- *Cpp17CopyAssignable* ([[cpp17.copyassignable]]),
-- *Cpp17Swappable* [[swappable.requirements]], and
-- *Cpp17Destructible* ([[cpp17.destructible]])
-requirements, and the expressions shown in [[formatter.basic]] are valid
-and have the indicated semantics.
-A type `F` meets the requirements if it meets the requirements and the
-expressions shown in [[formatter]] are valid and have the indicated
-semantics.
-Given character type `charT`, output iterator type `Out`, and formatting
-argument type `T`, in [[formatter.basic]] and [[formatter]]:
-- `f` is a value of type (possibly const) `F`,
-- `g` is an lvalue of type `F`,
-- `u` is an lvalue of type `T`,
-- `t` is a value of a type convertible to (possibly const) `T`,
-- `PC` is `basic_format_parse_context<charT>`,
-- `FC` is `basic_format_context<Out, charT>`,
-- `pc` is an lvalue of type `PC`, and
-- `fc` is an lvalue of type `FC`.
-`pc.begin()` points to the beginning of the *format-spec*
-[[format.string]] of the replacement field being formatted in the format
-string. If *format-spec* is empty then either `pc.begin() == pc.end()`
-or `*pc.begin() == '}'`.
-[*Note 1*: This allows formatters to emit meaningful error
-messages. — *end note*]
-**Table: \newoldconcept{Formatter} requirements** <a id="formatter">[formatter]</a>
-| Expression        | Return type    | Requirement                                                                                                                                                                                                                                                                                                                                 |
-| ----------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `f.format(t, fc)` | `FC::iterator` | Formats `t` according to the specifiers stored in `*this`, writes the output to `fc.out()`, and returns an iterator past the end of the output range. The output shall only depend on `t`, `fc.locale()`, `fc.arg(n)` for any value `n` of type `size_t`, and the range {[}`pc.begin()`, `pc.end()`{)} from the last call to `f.parse(pc)`. |
-| `f.format(u, fc)` | `FC::iterator` | As above, but does not modify `u`.                                                                                                                                                                                                                                                                                                          |
-#### Concept  <a id="format.formattable">[[format.formattable]]</a>
-Let `fmt-iter-for<charT>` be an unspecified type that models
-`output_iterator<const charT&>` [[iterator.concept.output]].
-``` cpp
-template<class T, class Context,
-         class Formatter = typename Context::template formatter_type<remove_const_t<T>>>
-  concept formattable-with =                // exposition only
-    semiregular<Formatter> &&
-    requires(Formatter& f, const Formatter& cf, T&& t, Context fc,
-             basic_format_parse_context<typename Context::char_type> pc)
-    {
-      { f.parse(pc) } -> same_as<typename decltype(pc)::iterator>;
-      { cf.format(t, fc) } -> same_as<typename Context::iterator>;
-    };
-template<class T, class charT>
-  concept formattable =
-    formattable-with<remove_reference_t<T>, basic_format_context<fmt-iter-for<charT>>>;
-```
-A type `T` and a character type `charT` model `formattable` if
-`formatter<remove_cvref_t<T>, charT>` meets the requirements
-[[formatter.requirements]] and, if `remove_reference_t<T>` is
-const-qualified, the requirements.
-#### Formatter specializations <a id="format.formatter.spec">[[format.formatter.spec]]</a>
-The functions defined in [[format.functions]] use specializations of the
-class template `formatter` to format individual arguments.
-Let `charT` be either `char` or `wchar_t`. Each specialization of
-`formatter` is either enabled or disabled, as described below. A
-*debug-enabled* specialization of `formatter` additionally provides a
-public, constexpr, non-static member function `set_debug_format()` which
-modifies the state of the `formatter` to be as if the type of the
-*std-format-spec* parsed by the last call to `parse` were `?`. Each
-header that declares the template `formatter` provides the following
-enabled specializations:
-- The debug-enabled specializations
-  ``` cpp
-  template<> struct formatter<char, char>;
-  template<> struct formatter<char, wchar_t>;
-  template<> struct formatter<wchar_t, wchar_t>;
-  ```
-- For each `charT`, the debug-enabled string type specializations
-  ``` cpp
-  template<> struct formatter<charT*, charT>;
-  template<> struct formatter<const charT*, charT>;
-  template<size_t N> struct formatter<charT[N], charT>;
-  template<class traits, class Allocator>
-    struct formatter<basic_string<charT, traits, Allocator>, charT>;
-  template<class traits>
-    struct formatter<basic_string_view<charT, traits>, charT>;
-  ```
-- For each `charT`, for each cv-unqualified arithmetic type
-  `ArithmeticT` other than `char`, `wchar_t`, `char8_t`, `char16_t`, or
-  `char32_t`, a specialization
-  ``` cpp
-  template<> struct formatter<ArithmeticT, charT>;
-  ```
-- For each `charT`, the pointer type specializations
-  ``` cpp
-  template<> struct formatter<nullptr_t, charT>;
-  template<> struct formatter<void*, charT>;
-  template<> struct formatter<const void*, charT>;
-  ```
-The `parse` member functions of these formatters interpret the format
-specification as a *std-format-spec* as described in
-[[format.string.std]].
-[*Note 1*: Specializations such as `formatter<wchar_t, char>` and
-`formatter<const char*, wchar_t>` that would require implicit multibyte
-/ wide string or character conversion are disabled. — *end note*]
-For any types `T` and `charT` for which neither the library nor the user
-provides an explicit or partial specialization of the class template
-`formatter`, `formatter<T, charT>` is disabled.
-If the library provides an explicit or partial specialization of
-`formatter<T, charT>`, that specialization is enabled and meets the
-requirements except as noted otherwise.
-If `F` is a disabled specialization of `formatter`, these values are
-`false`:
-- `is_default_constructible_v<F>`,
-- `is_copy_constructible_v<F>`,
-- `is_move_constructible_v<F>`,
-- `is_copy_assignable_v<F>`, and
-- `is_move_assignable_v<F>`.
-An enabled specialization `formatter<T, charT>` meets the requirements
-[[formatter.requirements]].
-[*Example 1*:
-``` cpp
-#include <format>
-enum color { red, green, blue };
-const char* color_names[] = { "red", "green", "blue" };
-template<> struct std::formatter<color> : std::formatter<const char*> {
-  auto format(color c, format_context& ctx) const {
-    return formatter<const char*>::format(color_names[c], ctx);
-  }
-};
-struct err {};
-std::string s0 = std::format("{}", 42);         // OK, library-provided formatter
-std::string s1 = std::format("{}", L"foo");     // error: disabled formatter
-std::string s2 = std::format("{}", red);        // OK, user-provided formatter
-std::string s3 = std::format("{}", err{});      // error: disabled formatter
-```
-— *end example*]
-#### Formatting escaped characters and strings <a id="format.string.escaped">[[format.string.escaped]]</a>
-A character or string can be formatted as *escaped* to make it more
-suitable for debugging or for logging.
-The escaped string *E* representation of a string *S* is constructed by
-encoding a sequence of characters as follows. The associated character
-encoding *CE* for `charT` ([[lex.string.literal]]) is used to both
-interpret *S* and construct *E*.
-- U+0022 (quotation mark) (`"`) is appended to *E*.
-- For each code unit sequence *X* in *S* that either encodes a single
-  character, is a shift sequence, or is a sequence of ill-formed code
-  units, processing is in order as follows:
-  - If *X* encodes a single character *C*, then:
-    - If *C* is one of the characters in [[format.escape.sequences]],
-      then the two characters shown as the corresponding escape sequence
-      are appended to *E*.
-    - Otherwise, if *C* is not U+0020 (space) and
-      - *CE* is UTF-8, UTF-16, or UTF-32 and *C* corresponds to a
-        Unicode scalar value whose Unicode property `General_Category`
-        has a value in the groups `Separator` (`Z`) or `Other` (`C`), as
-        described by UAX \#44 of the Unicode Standard, or
-      - *CE* is UTF-8, UTF-16, or UTF-32 and *C* corresponds to a
-        Unicode scalar value with the Unicode property
-        `Grapheme_Extend=Yes` as described by UAX \#44 of the Unicode
-        Standard and *C* is not immediately preceded in *S* by a
-        character *P* appended to *E* without translation to an escape
-        sequence, or
-      - *CE* is neither UTF-8, UTF-16, nor UTF-32 and *C* is one of an
-        implementation-defined set of separator or non-printable
-        characters
-      then the sequence `\u{hex-digit-sequence}` is appended to *E*,
-      where `hex-digit-sequence` is the shortest hexadecimal
-      representation of *C* using lower-case hexadecimal digits.
-    - Otherwise, *C* is appended to *E*.
-  - Otherwise, if *X* is a shift sequence, the effect on *E* and further
-    decoding of *S* is unspecified. *Recommended practice:* A shift
-    sequence should be represented in *E* such that the original code
-    unit sequence of *S* can be reconstructed.
-  - Otherwise (*X* is a sequence of ill-formed code units), each code
-    unit *U* is appended to *E* in order as the sequence
-    `\x{hex-digit-sequence}`, where `hex-digit-sequence` is the shortest
-    hexadecimal representation of *U* using lower-case hexadecimal
-    digits.
-- Finally, U+0022 (quotation mark) (`"`) is appended to *E*.
-**Table: Mapping of characters to escape sequences** <a id="format.escape.sequences">[format.escape.sequences]</a>
-| Character                     | Escape sequence |
-| ----------------------------- | --------------- |
-| U+0009 (character tabulation) | `\t`            |
-| % U+000a (line feed)          | `\n`            |
-| % U+000d (carriage return)    | `\r`            |
-| % U+0022 (quotation mark)     | `\"`            |
-| % U+005c (reverse solidus)    | ``              |
-The escaped string representation of a character *C* is equivalent to
-the escaped string representation of a string of *C*, except that:
-- the result starts and ends with U+0027 (apostrophe) (`'`) instead of
-  U+0022 (quotation mark) (`"`), and
-- if *C* is U+0027 (apostrophe), the two characters `\'` are appended to
-  *E*, and
-- if *C* is U+0022 (quotation mark), then *C* is appended unchanged.
-[*Example 1*:
-``` cpp
-string s0 = format("[{}]", "h\tllo");               // s0 has value: [h\ \ \ \ llo]
-string s1 = format("[{:?}]", "h\tllo");             // s1 has value: ["h\ tllo"]
-string s3 = format("[{:?}, {:?}]", '\'', '"');      // s3 has value: ['\ '', '"']
-// The following examples assume use of the UTF-8 encoding
-string s4 = format("[{:?}]", string("\0 \n \t \x02 \x1b", 9));
-                                                    // s4 has value: ["\ u{0\ \ n \ t \ u{2} \ u{1b}"]}
-string s5 = format("[{:?}]", "\xc3\x28");           // invalid UTF-8, s5 has value: ["\ x{c3\("]}
-string s7 = format("[{:?}]", "\u0301");             // s7 has value: ["\ u{301"]}
-string s8 = format("[{:?}]", "\\\u0301");           // s8 has value: ["\ \ \ u{301"]}
-```
-— *end example*]
-#### Class template `basic_format_parse_context` <a id="format.parse.ctx">[[format.parse.ctx]]</a>
-``` cpp
-namespace std {
-  template<class charT>
-  class basic_format_parse_context {
-  public:
-    using char_type = charT;
-    using const_iterator = typename basic_string_view<charT>::const_iterator;
-    using iterator = const_iterator;
-  private:
-    iterator begin_;                                    // exposition only
-    iterator end_;                                      // exposition only
-    enum indexing { unknown, manual, automatic };       // exposition only
-    indexing indexing_;                                 // exposition only
-    size_t next_arg_id_;                                // exposition only
-    size_t num_args_;                                   // exposition only
-  public:
-    constexpr explicit basic_format_parse_context(basic_string_view<charT> fmt,
-                                                  size_t num_args = 0) noexcept;
-    basic_format_parse_context(const basic_format_parse_context&) = delete;
-    basic_format_parse_context& operator=(const basic_format_parse_context&) = delete;
-    constexpr const_iterator begin() const noexcept;
-    constexpr const_iterator end() const noexcept;
-    constexpr void advance_to(const_iterator it);
-    constexpr size_t next_arg_id();
-    constexpr void check_arg_id(size_t id);
-  };
-}
-```
-An instance of `basic_format_parse_context` holds the format string
-parsing state consisting of the format string range being parsed and the
-argument counter for automatic indexing.
-``` cpp
-constexpr explicit basic_format_parse_context(basic_string_view<charT> fmt,
-                                              size_t num_args = 0) noexcept;
-```
-*Effects:* Initializes `begin_` with `fmt.begin()`, `end_` with
-`fmt.end()`, `indexing_` with `unknown`, `next_arg_id_` with `0`, and
-`num_args_` with `num_args`.
-``` cpp
-constexpr const_iterator begin() const noexcept;
-```
-*Returns:* `begin_`.
-``` cpp
-constexpr const_iterator end() const noexcept;
-```
-*Returns:* `end_`.
-``` cpp
-constexpr void advance_to(const_iterator it);
-```
-*Preconditions:* `end()` is reachable from `it`.
-*Effects:* Equivalent to: `begin_ = it;`
-``` cpp
-constexpr size_t next_arg_id();
-```
-*Effects:* If `indexing_ != manual` is `true`, equivalent to:
-``` cpp
-if (indexing_ == unknown)
-  indexing_ = automatic;
-return next_arg_id_++;
-```
-*Throws:* `format_error` if `indexing_ == manual` is `true` which
-indicates mixing of automatic and manual argument indexing.
-*Remarks:* Let *`cur-arg-id`* be the value of `next_arg_id_` prior to
-this call. Call expressions where *`cur-arg-id`*` >= num_args_` is
-`true` are not core constant expressions [[expr.const]].
-``` cpp
-constexpr void check_arg_id(size_t id);
-```
-*Effects:* If `indexing_ != automatic` is `true`, equivalent to:
-``` cpp
-if (indexing_ == unknown)
-  indexing_ = manual;
-```
-*Throws:* `format_error` if `indexing_ == automatic` is `true` which
-indicates mixing of automatic and manual argument indexing.
-*Remarks:* Call expressions where `id >= num_args_` is `true` are not
-core constant expressions [[expr.const]].
-#### Class template `basic_format_context` <a id="format.context">[[format.context]]</a>
-``` cpp
-namespace std {
-  template<class Out, class charT>
-  class basic_format_context {
-    basic_format_args<basic_format_context> args_;      // exposition only
-    Out out_;                                           // exposition only
-  public:
-    using iterator = Out;
-    using char_type = charT;
-    template<class T> using formatter_type = formatter<T, charT>;
-    basic_format_arg<basic_format_context> arg(size_t id) const noexcept;
-    std::locale locale();
-    iterator out();
-    void advance_to(iterator it);
-  };
-}
-```
-An instance of `basic_format_context` holds formatting state consisting
-of the formatting arguments and the output iterator.
-`Out` shall model `output_iterator<const charT&>`.
-`format_context` is an alias for a specialization of
-`basic_format_context` with an output iterator that appends to `string`,
-such as `back_insert_iterator<string>`. Similarly, `wformat_context` is
-an alias for a specialization of `basic_format_context` with an output
-iterator that appends to `wstring`.
-*Recommended practice:* For a given type `charT`, implementations should
-provide a single instantiation of `basic_format_context` for appending
-to `basic_string<charT>`, `vector<charT>`, or any other container with
-contiguous storage by wrapping those in temporary objects with a uniform
-interface (such as a `span<charT>`) and polymorphic reallocation.
-``` cpp
-basic_format_arg<basic_format_context> arg(size_t id) const noexcept;
-```
-*Returns:* `args_.get(id)`.
-``` cpp
-std::locale locale();
-```
-*Returns:* The locale passed to the formatting function if the latter
-takes one, and `std::locale()` otherwise.
-``` cpp
-iterator out();
-```
-*Effects:* Equivalent to: `return std::move(out_);`
-``` cpp
-void advance_to(iterator it);
-```
-*Effects:* Equivalent to: `out_ = std::move(it);`
-[*Example 1*:
-``` cpp
-struct S { int value; };
-template<> struct std::formatter<S> {
-  size_t width_arg_id = 0;
-  // Parses a width argument id in the format { digit }.
-  constexpr auto parse(format_parse_context& ctx) {
-    auto iter = ctx.begin();
-    auto get_char = [&]() { return iter != ctx.end() ? *iter : 0; };
-    if (get_char() != '{')
-      return iter;
-    ++iter;
-    char c = get_char();
-    if (!isdigit(c) || (++iter, get_char()) != '}')
-      throw format_error("invalid format");
-    width_arg_id = c - '0';
-    ctx.check_arg_id(width_arg_id);
-    return ++iter;
-  }
-  // Formats an S with width given by the argument width_arg_id.
-  auto format(S s, format_context& ctx) const {
-    int width = visit_format_arg([](auto value) -> int {
-      if constexpr (!is_integral_v<decltype(value)>)
-        throw format_error("width is not integral");
-      else if (value < 0 || value > numeric_limits<int>::max())
-        throw format_error("invalid width");
-      else
-        return value;
-      }, ctx.arg(width_arg_id));
-    return format_to(ctx.out(), "{0:x<{1}}", s.value, width);
-  }
-};
-std::string s = std::format("{0:{1}}", S{42}, 10);  // value of s is "xxxxxxxx42"
-```
-— *end example*]
-### Formatting of ranges <a id="format.range">[[format.range]]</a>
-#### Variable template `format_kind` <a id="format.range.fmtkind">[[format.range.fmtkind]]</a>
-``` cpp
-template<ranges::input_range R>
-    requires same_as<R, remove_cvref_t<R>>
-  constexpr range_format format_kind<R> = see below;
-```
-A program that instantiates the primary template of `format_kind` is
-ill-formed.
-For a type `R`, `format_kind<R>` is defined as follows:
-- If `same_as<remove_cvref_t<ranges::range_reference_t<R>>, R>` is
-  `true`, `format_kind<R>` is `range_format::disabled`. \[*Note 1*: This
-  prevents constraint recursion for ranges whose reference type is the
-  same range type. For example, `std::filesystem::path` is a range of
-  `std::filesystem::path`. — *end note*]
-- Otherwise, if the *qualified-id* `R::key_type` is valid and denotes a
-  type:
-  - If the *qualified-id* `R::mapped_type` is valid and denotes a type,
-    let `U` be `remove_cvref_t<ranges::range_reference_t<R>>`. If either
-    `U` is a specialization of `pair` or `U` is a specialization of
-    `tuple` and `tuple_size_v<U> == 2`, `format_kind<R>` is
-    `range_format::map`.
-  - Otherwise, `format_kind<R>` is `range_format::set`.
-- Otherwise, `format_kind<R>` is `range_format::sequence`.
-*Remarks:* Pursuant to [[namespace.std]], users may specialize
-`format_kind` for cv-unqualified program-defined types that model
-`ranges::input_range`. Such specializations shall be usable in constant
-expressions [[expr.const]] and have type `const range_format`.
-#### Class template `range_formatter` <a id="format.range.formatter">[[format.range.formatter]]</a>
-``` cpp
-namespace std {
-  template<class T, class charT = char>
-    requires same_as<remove_cvref_t<T>, T> && formattable<T, charT>
-  class range_formatter {
-    formatter<T, charT> underlying_;                                          // exposition only
-    basic_string_view<charT> separator_ = STATICALLY-WIDEN<charT>(", ");      // exposition only
-    basic_string_view<charT> opening-bracket_ = STATICALLY-WIDEN<charT>("["); // exposition only
-    basic_string_view<charT> closing-bracket_ = STATICALLY-WIDEN<charT>("]"); // exposition only
-  public:
-    constexpr void set_separator(basic_string_view<charT> sep) noexcept;
-    constexpr void set_brackets(basic_string_view<charT> opening,
-                                basic_string_view<charT> closing) noexcept;
-    constexpr formatter<T, charT>& underlying() noexcept { return underlying_; }
-    constexpr const formatter<T, charT>& underlying() const noexcept { return underlying_; }
-    template<class ParseContext>
-      constexpr typename ParseContext::iterator
-        parse(ParseContext& ctx);
-    template<ranges::input_range R, class FormatContext>
-        requires formattable<ranges::range_reference_t<R>, charT> &&
-                 same_as<remove_cvref_t<ranges::range_reference_t<R>>, T>
-      typename FormatContext::iterator
-        format(R&& r, FormatContext& ctx) const;
-  };
-}
-```
-The class template `range_formatter` is a utility for implementing
-`formatter` specializations for range types.
-`range_formatter` interprets *format-spec* as a *range-format-spec*. The
-syntax of format specifications is as follows:
-``` bnf
-range-format-spec
-    range-fill-and-alignₒₚₜ widthₒₚₜ 'n'ₒₚₜ range-typeₒₚₜ range-underlying-specₒₚₜ
-```
-``` bnf
-range-fill-and-align
-    range-fillₒₚₜ align
-```
-``` bnf
-range-fill
-    any character other than '{' or '}' or ':'
-```
-``` bnf
-range-type
-    'm'
-    's'
-    '?s'
-```
-``` bnf
-range-underlying-spec
-    ':' format-spec
-```
-For `range_formatter<T, charT>`, the *format-spec* in a
-*range-underlying-spec*, if any, is interpreted by
-`formatter<T, charT>`.
-The *range-fill-and-align* is interpreted the same way as a
-*fill-and-align* [[format.string.std]]. The productions *align* and
-*width* are described in [[format.string]].
-The `n` option causes the range to be formatted without the opening and
-closing brackets.
-[*Note 1*: This is equivalent to invoking
-`set_brackets({}, {})`. — *end note*]
-The *range-type* specifier changes the way a range is formatted, with
-certain options only valid with certain argument types. The meaning of
-the various type options is as specified in [[formatter.range.type]].
-**Table: Meaning of range-type options** <a id="formatter.range.type">[formatter.range.type]</a>
-| Option | Requirements                                                                                                      | Meaning                                                                                                                                                                                                                                                                                                                                |
-| ------ | ----------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| % `m`  | `T` shall be either a specialization of `pair` or a specialization of `tuple` such that `tuple_size_v<T>` is `2`. | Indicates that the opening bracket should be `"{"`, the closing bracket should be `"}"`, the separator should be `", "`, and each range element should be formatted as if `m` were specified for its tuple-type. *If the `n` option is provided in addition to the `m` option, both the opening and closing brackets are still empty.* |
-| % `s`  | `T` shall be `charT`.                                                                                             | Indicates that the range should be formatted as a `string`.                                                                                                                                                                                                                                                                            |
-| % `?s` | `T` shall be `charT`.                                                                                             | Indicates that the range should be formatted as an escaped string [[format.string.escaped]].                                                                                                                                                                                                                                           |
-If the *range-type* is `s` or `?s`, then there shall be no `n` option
-and no *range-underlying-spec*.
-``` cpp
-constexpr void set_separator(basic_string_view<charT> sep) noexcept;
-```
-*Effects:* Equivalent to: *`separator_`*` = sep;`
-``` cpp
-constexpr void set_brackets(basic_string_view<charT> opening,
-                            basic_string_view<charT> closing) noexcept;
-```
-*Effects:* Equivalent to:
-``` cpp
-opening-bracket_ = opening;
-closing-bracket_ = closing;
-```
-``` cpp
-template<class ParseContext>
-  constexpr typename ParseContext::iterator
-    parse(ParseContext& ctx);
-```
-*Effects:* Parses the format specifier as a *range-format-spec* and
-stores the parsed specifiers in `*this`. The values of
-*opening-bracket\_*, *closing-bracket\_*, and *separator\_* are modified
-if and only if required by the *range-type* or the `n` option, if
-present. If:
-- the *range-type* is neither `s` nor `?s`,
-- *`underlying_`*`.set_debug_format()` is a valid expression, and
-- there is no *range-underlying-spec*,
-then calls *`underlying_`*`.set_debug_format()`.
-*Returns:* An iterator past the end of the *range-format-spec*.
-``` cpp
-template<ranges::input_range R, class FormatContext>
-    requires formattable<ranges::range_reference_t<R>, charT> &&
-             same_as<remove_cvref_t<ranges::range_reference_t<R>>, T>
-  typename FormatContext::iterator
-    format(R&& r, FormatContext& ctx) const;
-```
-*Effects:* Writes the following into `ctx.out()`, adjusted according to
-the *range-format-spec*:
-- If the *range-type* was `s`, then as if by formatting
-  `basic_string<charT>(from_range, r)`.
-- Otherwise, if the *range-type* was `?s`, then as if by formatting
-  `basic_string<charT>(from_range, r)` as an escaped
-  string [[format.string.escaped]].
-- Otherwise,
-  - *opening-bracket\_*,
-  - for each element `e` of the range `r`:
-    - the result of writing `e` via *underlying\_* and
-    - *separator\_*, unless `e` is the last element of `r`, and
-  - *closing-bracket\_*.
-*Returns:* An iterator past the end of the output range.
-#### Class template *`range-default-formatter`* <a id="format.range.fmtdef">[[format.range.fmtdef]]</a>
-``` cpp
-namespace std {
-  template<ranges::input_range R, class charT>
-  struct range-default-formatter<range_format::sequence, R, charT> {    // exposition only
-  private:
-    using maybe-const-r = fmt-maybe-const<R, charT>;                    // exposition only
-    range_formatter<remove_cvref_t<ranges::range_reference_t<maybe-const-r>>,
-                    charT> underlying_;                                 // exposition only
-  public:
-    constexpr void set_separator(basic_string_view<charT> sep) noexcept;
-    constexpr void set_brackets(basic_string_view<charT> opening,
-                                basic_string_view<charT> closing) noexcept;
-    template<class ParseContext>
-      constexpr typename ParseContext::iterator
-        parse(ParseContext& ctx);
-    template<class FormatContext>
-      typename FormatContext::iterator
-        format(maybe-const-r& elems, FormatContext& ctx) const;
-  };
-}
-```
-``` cpp
-constexpr void set_separator(basic_string_view<charT> sep) noexcept;
-```
-*Effects:* Equivalent to: *`underlying_`*`.set_separator(sep);`
-``` cpp
-constexpr void set_brackets(basic_string_view<charT> opening,
-                            basic_string_view<charT> closing) noexcept;
-```
-*Effects:* Equivalent to:
-*`underlying_`*`.set_brackets(opening, closing);`
-``` cpp
-template<class ParseContext>
-  constexpr typename ParseContext::iterator
-    parse(ParseContext& ctx);
-```
-*Effects:* Equivalent to: `return `*`underlying_`*`.parse(ctx);`
-``` cpp
-template<class FormatContext>
-  typename FormatContext::iterator
-    format(maybe-const-r& elems, FormatContext& ctx) const;
-```
-*Effects:* Equivalent to: `return `*`underlying_`*`.format(elems, ctx);`
-#### Specialization of *`range-default-formatter`* for maps <a id="format.range.fmtmap">[[format.range.fmtmap]]</a>
-``` cpp
-namespace std {
-  template<ranges::input_range R, class charT>
-  struct range-default-formatter<range_format::map, R, charT> {
-  private:
-    using maybe-const-map = fmt-maybe-const<R, charT>;                  // exposition only
-    using element-type =                                                // exposition only
-      remove_cvref_t<ranges::range_reference_t<maybe-const-map>>;
-    range_formatter<element-type, charT> underlying_;                   // exposition only
-  public:
-    constexpr range-default-formatter();
-    template<class ParseContext>
-      constexpr typename ParseContext::iterator
-        parse(ParseContext& ctx);
-    template<class FormatContext>
-      typename FormatContext::iterator
-        format(maybe-const-map& r, FormatContext& ctx) const;
-  };
-}
-```
-``` cpp
-constexpr range-default-formatter();
-```
-*Mandates:* Either:
-- *element-type* is a specialization of `pair`, or
-- *element-type* is a specialization of `tuple` and
-  `tuple_size_v<`*`element-type`*`> == 2`.
-*Effects:* Equivalent to:
-``` cpp
-underlying_.set_brackets(STATICALLY-WIDEN<charT>("{"), STATICALLY-WIDEN<charT>("}"));
-underlying_.underlying().set_brackets({}, {});
-underlying_.underlying().set_separator(STATICALLY-WIDEN<charT>(": "));
-```
-``` cpp
-template<class ParseContext>
-  constexpr typename ParseContext::iterator
-    parse(ParseContext& ctx);
-```
-*Effects:* Equivalent to: `return `*`underlying_`*`.parse(ctx);`
-``` cpp
-template<class FormatContext>
-  typename FormatContext::iterator
-    format(maybe-const-map& r, FormatContext& ctx) const;
-```
-*Effects:* Equivalent to: `return `*`underlying_`*`.format(r, ctx);`
-#### Specialization of *`range-default-formatter`* for sets <a id="format.range.fmtset">[[format.range.fmtset]]</a>
-``` cpp
-namespace std {
-  template<ranges::input_range R, class charT>
-  struct range-default-formatter<range_format::set, R, charT> {
-  private:
-    using maybe-const-set = fmt-maybe-const<R, charT>;                  // exposition only
-    range_formatter<remove_cvref_t<ranges::range_reference_t<maybe-const-set>>,
-                    charT> underlying_;                                 // exposition only
-  public:
-    constexpr range-default-formatter();
-    template<class ParseContext>
-      constexpr typename ParseContext::iterator
-        parse(ParseContext& ctx);
-    template<class FormatContext>
-      typename FormatContext::iterator
-        format(maybe-const-set& r, FormatContext& ctx) const;
-  };
-}
-```
-``` cpp
-constexpr range-default-formatter();
-```
-*Effects:* Equivalent to:
-``` cpp
-underlying_.set_brackets(STATICALLY-WIDEN<charT>("{"), STATICALLY-WIDEN<charT>("}"));
-```
-``` cpp
-template<class ParseContext>
-  constexpr typename ParseContext::iterator
-    parse(ParseContext& ctx);
-```
-*Effects:* Equivalent to: `return `*`underlying_`*`.parse(ctx);`
-``` cpp
-template<class FormatContext>
-  typename FormatContext::iterator
-    format(maybe-const-set& r, FormatContext& ctx) const;
-```
-*Effects:* Equivalent to: `return `*`underlying_`*`.format(r, ctx);`
-#### Specialization of *`range-default-formatter`* for strings <a id="format.range.fmtstr">[[format.range.fmtstr]]</a>
-``` cpp
-namespace std {
-  template<range_format K, ranges::input_range R, class charT>
-    requires (K == range_format::string || K == range_format::debug_string)
-  struct range-default-formatter<K, R, charT> {
-  private:
-    formatter<basic_string<charT>, charT> underlying_;                  // exposition only
-  public:
-    template<class ParseContext>
-      constexpr typename ParseContext::iterator
-        parse(ParseContext& ctx);
-    template<class FormatContext>
-      typename FormatContext::iterator
-        format(see below& str, FormatContext& ctx) const;
-  };
-}
-```
-*Mandates:* `same_as<remove_cvref_t<range_reference_t<R>>, charT>` is
-`true`.
-``` cpp
-template<class ParseContext>
-  constexpr typename ParseContext::iterator
-    parse(ParseContext& ctx);
-```
-*Effects:* Equivalent to:
-``` cpp
-auto i = underlying_.parse(ctx);
-if constexpr (K == range_format::debug_string) {
-  underlying_.set_debug_format();
-}
-return i;
-```
-``` cpp
-template<class FormatContext>
-  typename FormatContext::iterator
-    format(see below& r, FormatContext& ctx) const;
-```
-The type of `r` is `const R&` if `ranges::input_range<const R>` is
-`true` and `R&` otherwise.
-*Effects:* Let *`s`* be a `basic_string<charT>` such that
-`ranges::equal(`*`s`*`, r)` is `true`. Equivalent to:
-`return `*`underlying_`*`.format(`*`s`*`, ctx);`
-### Arguments <a id="format.arguments">[[format.arguments]]</a>
-#### Class template `basic_format_arg` <a id="format.arg">[[format.arg]]</a>
-``` cpp
-namespace std {
-  template<class Context>
-  class basic_format_arg {
-  public:
-    class handle;
-  private:
-    using char_type = typename Context::char_type;                              // exposition only
-    variant<monostate, bool, char_type,
-            int, unsigned int, long long int, unsigned long long int,
-            float, double, long double,
-            const char_type*, basic_string_view<char_type>,
-            const void*, handle> value;                                         // exposition only
-    template<class T> explicit basic_format_arg(T& v) noexcept;                 // exposition only
-  public:
-    basic_format_arg() noexcept;
-    explicit operator bool() const noexcept;
-  };
-}
-```
-An instance of `basic_format_arg` provides access to a formatting
-argument for user-defined formatters.
-The behavior of a program that adds specializations of
-`basic_format_arg` is undefined.
-``` cpp
-basic_format_arg() noexcept;
-```
-*Ensures:* `!(*this)`.
-``` cpp
-template<class T> explicit basic_format_arg(T& v) noexcept;
-```
-*Constraints:* `T` satisfies `formattable-with<Context>`.
-*Preconditions:* If `decay_t<T>` is `char_type*` or `const char_type*`,
-`static_cast<const char_type*>(v)` points to a NTCTS [[defns.ntcts]].
-*Effects:* Let `TD` be `remove_const_t<T>`.
-- If `TD` is `bool` or `char_type`, initializes `value` with `v`;
-- otherwise, if `TD` is `char` and `char_type` is `wchar_t`, initializes
-  `value` with `static_cast<wchar_t>(v)`;
-- otherwise, if `TD` is a signed integer type [[basic.fundamental]] and
-  `sizeof(TD) <= sizeof(int)`, initializes `value` with
-  `static_cast<int>(v)`;
-- otherwise, if `TD` is an unsigned integer type and
-  `sizeof(TD) <= sizeof(unsigned int)`, initializes `value` with
-  `static_cast<unsigned int>(v)`;
-- otherwise, if `TD` is a signed integer type and
-  `sizeof(TD) <= sizeof(long long int)`, initializes `value` with
-  `static_cast<long long int>(v)`;
-- otherwise, if `TD` is an unsigned integer type and
-  `sizeof(TD) <= sizeof(unsigned long long int)`, initializes `value`
-  with `static_cast<unsigned long long int>(v)`;
-- otherwise, if `TD` is a standard floating-point type, initializes
-  `value` with `v`;
-- otherwise, if `TD` is a specialization of `basic_string_view` or
-  `basic_string` and `TD::value_type` is `char_type`, initializes
-  `value` with `basic_string_view<char_type>(v.data(), v.size())`;
-- otherwise, if `decay_t<TD>` is `char_type*` or `const char_type*`,
-  initializes `value` with `static_cast<const char_type*>(v)`;
-- otherwise, if `is_void_v<remove_pointer_t<TD>>` is `true` or
-  `is_null_pointer_v<TD>` is `true`, initializes `value` with
-  `static_cast<const void*>(v)`;
-- otherwise, initializes `value` with `handle(v)`.
-[*Note 1*: Constructing `basic_format_arg` from a pointer to a member
-is ill-formed unless the user provides an enabled specialization of
-`formatter` for that pointer to member type. — *end note*]
-``` cpp
-explicit operator bool() const noexcept;
-```
-*Returns:* `!holds_alternative<monostate>(value)`.
-The class `handle` allows formatting an object of a user-defined type.
-``` cpp
-namespace std {
-  template<class Context>
-  class basic_format_arg<Context>::handle {
-    const void* ptr_;                                           // exposition only
-    void (*format_)(basic_format_parse_context<char_type>&,
-                    Context&, const void*);                     // exposition only
-    template<class T> explicit handle(T& val) noexcept;         // exposition only
-    friend class basic_format_arg<Context>;                     // exposition only
-  public:
-    void format(basic_format_parse_context<char_type>&, Context& ctx) const;
-  };
-}
-```
-``` cpp
-template<class T> explicit handle(T& val) noexcept;
-```
-Let
-- `TD` be `remove_const_t<T>`,
-- `TQ` be `const TD` if `const TD` satisfies `formattable-with<Context>`
-  and `TD` otherwise.
-*Mandates:* `TQ` satisfies `formattable-with<Context>`.
-*Effects:* Initializes `ptr_` with `addressof(val)` and `format_` with
-``` cpp
-[](basic_format_parse_context<char_type>& parse_ctx,
-   Context& format_ctx, const void* ptr) {
-  typename Context::template formatter_type<TD> f;
-  parse_ctx.advance_to(f.parse(parse_ctx));
-  format_ctx.advance_to(f.format(*const_cast<TQ*>(static_cast<const TD*>(ptr)),
-                                 format_ctx));
-}
-```
-``` cpp
-void format(basic_format_parse_context<char_type>& parse_ctx, Context& format_ctx) const;
-```
-*Effects:* Equivalent to: `format_(parse_ctx, format_ctx, ptr_);`
-``` cpp
-template<class Visitor, class Context>
-  decltype(auto) visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
-```
-*Effects:* Equivalent to:
-`return visit(std::forward<Visitor>(vis), arg.value);`
-#### Class template *`format-arg-store`* <a id="format.arg.store">[[format.arg.store]]</a>
-``` cpp
-namespace std {
-  template<class Context, class... Args>
-  class format-arg-store {                                      // exposition only
-    array<basic_format_arg<Context>, sizeof...(Args)> args;     // exposition only
-  };
-}
-```
-An instance of *`format-arg-store`* stores formatting arguments.
-``` cpp
-template<class Context = format_context, class... Args>
-  format-arg-store<Context, Args...> make_format_args(Args&&... fmt_args);
-```
-*Preconditions:* The type
-`typename Context::template formatter_type<remove_cvref_t<``Tᵢ``>>`
-meets the requirements [[formatter.requirements]] for each `Tᵢ` in
-`Args`.
-*Returns:* An object of type *`format-arg-store`*`<Context, Args...>`
-whose *args* data member is initialized with
-`{basic_format_arg<Context>(fmt_args)...}`.
-``` cpp
-template<class... Args>
-  format-arg-store<wformat_context, Args...> make_wformat_args(Args&&... args);
-```
-*Effects:* Equivalent to:
-`return make_format_args<wformat_context>(args...);`
-#### Class template `basic_format_args` <a id="format.args">[[format.args]]</a>
-``` cpp
-namespace std {
-  template<class Context>
-  class basic_format_args {
-    size_t size_;                               // exposition only
-    const basic_format_arg<Context>* data_;     // exposition only
-  public:
-    basic_format_args() noexcept;
-    template<class... Args>
-      basic_format_args(const format-arg-store<Context, Args...>& store) noexcept;
-    basic_format_arg<Context> get(size_t i) const noexcept;
-  };
-  template<class Context, class... Args>
-    basic_format_args(format-arg-store<Context, Args...>) -> basic_format_args<Context>;
-}
-```
-An instance of `basic_format_args` provides access to formatting
-arguments. Implementations should optimize the representation of
-`basic_format_args` for a small number of formatting arguments.
-[*Note 1*: For example, by storing indices of type alternatives
-separately from values and packing the former. — *end note*]
-``` cpp
-basic_format_args() noexcept;
-```
-*Effects:* Initializes `size_` with `0`.
-``` cpp
-template<class... Args>
-  basic_format_args(const format-arg-store<Context, Args...>& store) noexcept;
-```
-*Effects:* Initializes `size_` with `sizeof...(Args)` and `data_` with
-`store.args.data()`.
-``` cpp
-basic_format_arg<Context> get(size_t i) const noexcept;
-```
-*Returns:* `i < size_ ? data_[i] : basic_format_arg<Context>()`.
-### Tuple formatter <a id="format.tuple">[[format.tuple]]</a>
-For each of `pair` and `tuple`, the library provides the following
-formatter specialization where `pair-or-tuple` is the name of the
-template:
-``` cpp
-namespace std {
-  template<class charT, formattable<charT>... Ts>
-  struct formatter<pair-or-tuple<Ts...>, charT> {
-  private:
-    tuple<formatter<remove_cvref_t<Ts>, charT>...> underlying_;               // exposition only
-    basic_string_view<charT> separator_ = STATICALLY-WIDEN<charT>(", ");      // exposition only
-    basic_string_view<charT> opening-bracket_ = STATICALLY-WIDEN<charT>("("); // exposition only
-    basic_string_view<charT> closing-bracket_ = STATICALLY-WIDEN<charT>(")"); // exposition only
-  public:
-    constexpr void set_separator(basic_string_view<charT> sep) noexcept;
-    constexpr void set_brackets(basic_string_view<charT> opening,
-                                basic_string_view<charT> closing) noexcept;
-    template<class ParseContext>
-      constexpr typename ParseContext::iterator
-        parse(ParseContext& ctx);
-    template<class FormatContext>
-      typename FormatContext::iterator
-        format(see below& elems, FormatContext& ctx) const;
-  };
-}
-```
-The `parse` member functions of these formatters interpret the format
-specification as a *tuple-format-spec* according to the following
-syntax:
-``` bnf
-tuple-format-spec
-    tuple-fill-and-alignₒₚₜ widthₒₚₜ tuple-typeₒₚₜ
-```
-``` bnf
-tuple-fill-and-align
-    tuple-fillₒₚₜ align
-```
-``` bnf
-tuple-fill
-    any character other than '{' or '}' or ':'
-```
-``` bnf
-tuple-type
-    'm'
-    'n'
-```
-The *tuple-fill-and-align* is interpreted the same way as a
-*fill-and-align* [[format.string.std]]. The productions *align* and
-*width* are described in [[format.string]].
-The *tuple-type* specifier changes the way a `pair` or `tuple` is
-formatted, with certain options only valid with certain argument types.
-The meaning of the various type options is as specified in
-[[formatter.tuple.type]].
-**Table: Meaning of tuple-type options** <a id="formatter.tuple.type">[formatter.tuple.type]</a>
-| Option | Requirements | Meaning                                |
-| ------ | ------------ | -------------------------------------- |
-| <charT>(": ")); set_brackets({}, {}); \end{codeblock}% |
-| % `n`  | none         | Equivalent to: `set_brackets({}, {});` |
-| % none | none         | No effects                             |
-``` cpp
-constexpr void set_separator(basic_string_view<charT> sep) noexcept;
-```
-*Effects:* Equivalent to: *`separator_`*` = sep;`
-``` cpp
-constexpr void set_brackets(basic_string_view<charT> opening,
-                            basic_string_view<charT> closing) noexcept;
-```
-*Effects:* Equivalent to:
-``` cpp
-opening-bracket_ = opening;
-closing-bracket_ = closing;
-```
-``` cpp
-template<class ParseContext>
-  constexpr typename ParseContext::iterator
-    parse(ParseContext& ctx);
-```
-*Effects:* Parses the format specifier as a *tuple-format-spec* and
-stores the parsed specifiers in `*this`. The values of
-*opening-bracket\_*, *closing-bracket\_*, and *separator\_* are modified
-if and only if required by the *tuple-type*, if present. For each
-element *`e`* in *underlying\_*, if *`e`*`.set_debug_format()` is a
-valid expression, calls *`e`*`.set_debug_format()`.
-*Returns:* An iterator past the end of the *tuple-format-spec*.
-``` cpp
-template<class FormatContext>
-  typename FormatContext::iterator
-    format(see below& elems, FormatContext& ctx) const;
-```
-The type of `elems` is:
-- If `(formattable<const Ts, charT> && ...)` is `true`,
-  `const `*`pair-or-tuple`*`<Ts...>&`.
-- Otherwise *`pair-or-tuple`*`<Ts...>&`.
-*Effects:* Writes the following into `ctx.out()`, adjusted according to
-the *tuple-format-spec*:
-- *opening-bracket\_*,
-- for each index `I` in the \[`0`, `sizeof...(Ts)`):
-  - if `I != 0`, *separator\_*,
-  - the result of writing `get<I>(elems)` via
-    `get<I>(`*`underlying_`*`)`, and
-- *closing-bracket\_*.
-*Returns:* An iterator past the end of the output range.
-### Class `format_error` <a id="format.error">[[format.error]]</a>
-``` cpp
-namespace std {
-  class format_error : public runtime_error {
-  public:
-    explicit format_error(const string& what_arg);
-    explicit format_error(const char* what_arg);
-  };
-}
-```
-The class `format_error` defines the type of objects thrown as
-exceptions to report errors from the formatting library.
-``` cpp
-format_error(const string& what_arg);
-```
-*Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
-``` cpp
-format_error(const char* what_arg);
-```
-*Ensures:* `strcmp(what(), what_arg) == 0`.
 ## Bit manipulation <a id="bit">[[bit]]</a>
 ### General <a id="bit.general">[[bit.general]]</a>
 The header `<bit>` provides components to access, manipulate and process
@@ -12428,13 +11111,13 @@ namespace std {
   template<class T>
     constexpr int bit_width(T x) noexcept;
   // [bit.rotate], rotating
   template<class T>
- [[nodiscard]] constexpr T rotl(T x, int s) noexcept;
   template<class T>
- [[nodiscard]] constexpr T rotr(T x, int s) noexcept;
   // [bit.count], counting
   template<class T>
     constexpr int countl_zero(T x) noexcept;
   template<class T>
@@ -12466,35 +11149,48 @@ template<class To, class From>
 - `sizeof(To) == sizeof(From)` is `true`;
 - `is_trivially_copyable_v<To>` is `true`; and
 - `is_trivially_copyable_v<From>` is `true`.
 *Returns:* An object of type `To`. Implicitly creates objects nested
 within the result [[intro.object]]. Each bit of the value representation
 of the result is equal to the corresponding bit in the object
 representation of `from`. Padding bits of the result are unspecified.
 For the result and each object created within it, if there is no value
 of the object’s type corresponding to the value representation produced,
 the behavior is undefined. If there are multiple such values, which
 value is produced is unspecified. A bit in the value representation of
 the result is indeterminate if it does not correspond to a bit in the
-value representation of `from` or corresponds to a bit of an object that
-is not within its lifetime or has an indeterminate
-value [[basic.indet]]. For each bit in the value representation of the
-result that is indeterminate, the smallest object containing that bit
-has an indeterminate value; the behavior is undefined unless that object
-is of unsigned ordinary character type or `std::byte` type. The result
-does not otherwise contain any indeterminate values.
-*Remarks:* This function is `constexpr` if and only if `To`, `From`, and
-the types of all subobjects of `To` and `From` are types `T` such that:
-- `is_union_v<T>` is `false`;
-- `is_pointer_v<T>` is `false`;
-- `is_member_pointer_v<T>` is `false`;
-- `is_volatile_v<T>` is `false`; and
-- `T` has no non-static data members of reference type.
 ### `byteswap` <a id="bit.byteswap">[[bit.byteswap]]</a>
 ``` cpp
 template<class T>
@@ -12567,11 +11263,11 @@ template<class T>
 In the following descriptions, let `N` denote
 `numeric_limits<T>::digits`.
 ``` cpp
 template<class T>
- [[nodiscard]] constexpr T rotl(T x, int s) noexcept;
 ```
 *Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
 Let `r` be `s % N`.
@@ -12579,11 +11275,11 @@ Let `r` be `s % N`.
 *Returns:* If `r` is `0`, `x`; if `r` is positive,
 `(x << r) | (x >> (N - r))`; if `r` is negative, `rotr(x, -r)`.
 ``` cpp
 template<class T>
- [[nodiscard]] constexpr T rotr(T x, int s) noexcept;
 ```
 *Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
 Let `r` be `s % N`.
@@ -12679,14 +11375,136 @@ If all scalar types have size 1 byte, then all of `endian::little`,
 big-endian, `endian::native` is equal to `endian::big`. If all scalar
 types are little-endian, `endian::native` is equal to `endian::little`.
 Otherwise, `endian::native` is not equal to either `endian::big` or
 `endian::little`.
 <!-- Link reference definitions -->
 [algorithms]: algorithms.md#algorithms
 [algorithms.general]: algorithms.md#algorithms.general
-[algorithms.requirements]: algorithms.md#algorithms.requirements
 [allocator.requirements.general]: library.md#allocator.requirements.general
 [allocator.uses.construction]: mem.md#allocator.uses.construction
 [any]: #any
 [any.assign]: #any.assign
 [any.bad.any.cast]: #any.bad.any.cast
@@ -12704,11 +11522,10 @@ Otherwise, `endian::native` is not equal to either `endian::big` or
 [arithmetic.operations.minus]: #arithmetic.operations.minus
 [arithmetic.operations.modulus]: #arithmetic.operations.modulus
 [arithmetic.operations.multiplies]: #arithmetic.operations.multiplies
 [arithmetic.operations.negate]: #arithmetic.operations.negate
 [arithmetic.operations.plus]: #arithmetic.operations.plus
-[associative]: containers.md#associative
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.indet]: basic.md#basic.indet
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.types.general]: basic.md#basic.types.general
 [bit]: #bit
@@ -12718,11 +11535,10 @@ Otherwise, `endian::native` is not equal to either `endian::big` or
 [bit.endian]: #bit.endian
 [bit.general]: #bit.general
 [bit.pow.two]: #bit.pow.two
 [bit.rotate]: #bit.rotate
 [bit.syn]: #bit.syn
-[bitmask.types]: library.md#bitmask.types
 [bitset]: #bitset
 [bitset.cons]: #bitset.cons
 [bitset.hash]: #bitset.hash
 [bitset.members]: #bitset.members
 [bitset.operators]: #bitset.operators
@@ -12731,14 +11547,10 @@ Otherwise, `endian::native` is not equal to either `endian::big` or
 [bitwise.operations.and]: #bitwise.operations.and
 [bitwise.operations.general]: #bitwise.operations.general
 [bitwise.operations.not]: #bitwise.operations.not
 [bitwise.operations.or]: #bitwise.operations.or
 [bitwise.operations.xor]: #bitwise.operations.xor
-[charconv]: #charconv
-[charconv.from.chars]: #charconv.from.chars
-[charconv.syn]: #charconv.syn
-[charconv.to.chars]: #charconv.to.chars
 [class.base.init]: class.md#class.base.init
 [class.copy.ctor]: class.md#class.copy.ctor
 [comparisons]: #comparisons
 [comparisons.equal.to]: #comparisons.equal.to
 [comparisons.general]: #comparisons.general
@@ -12747,34 +11559,23 @@ Otherwise, `endian::native` is not equal to either `endian::big` or
 [comparisons.less]: #comparisons.less
 [comparisons.less.equal]: #comparisons.less.equal
 [comparisons.not.equal.to]: #comparisons.not.equal.to
 [comparisons.three.way]: #comparisons.three.way
 [concepts.equality]: concepts.md#concepts.equality
 [cpp17.copyassignable]: #cpp17.copyassignable
-[cpp17.copyconstructible]: #cpp17.copyconstructible
 [cpp17.defaultconstructible]: #cpp17.defaultconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cpp17.hash]: #cpp17.hash
 [cpp17.moveassignable]: #cpp17.moveassignable
 [cpp17.moveconstructible]: #cpp17.moveconstructible
 [dcl.constexpr]: dcl.md#dcl.constexpr
 [dcl.init.general]: dcl.md#dcl.init.general
 [declval]: #declval
 [defns.expression.equivalent]: intro.md#defns.expression.equivalent
-[defns.ntcts]: intro.md#defns.ntcts
 [defns.order.ptr]: #defns.order.ptr
 [defns.referenceable]: intro.md#defns.referenceable
-[except.terminate]: except.md#except.terminate
-[execpol]: #execpol
-[execpol.general]: #execpol.general
-[execpol.objects]: #execpol.objects
-[execpol.par]: #execpol.par
-[execpol.parunseq]: #execpol.parunseq
-[execpol.seq]: #execpol.seq
-[execpol.type]: #execpol.type
-[execpol.unseq]: #execpol.unseq
-[execution.syn]: #execution.syn
 [expected]: #expected
 [expected.bad]: #expected.bad
 [expected.bad.void]: #expected.bad.void
 [expected.expected]: #expected.expected
 [expected.general]: #expected.general
@@ -12812,51 +11613,10 @@ Otherwise, `endian::native` is not equal to either `endian::big` or
 [expr.mul]: expr.md#expr.mul
 [expr.or]: expr.md#expr.or
 [expr.rel]: expr.md#expr.rel
 [expr.unary.op]: expr.md#expr.unary.op
 [expr.xor]: expr.md#expr.xor
-[format]: #format
-[format.align]: #format.align
-[format.arg]: #format.arg
-[format.arg.store]: #format.arg.store
-[format.args]: #format.args
-[format.arguments]: #format.arguments
-[format.context]: #format.context
-[format.err.report]: #format.err.report
-[format.error]: #format.error
-[format.escape.sequences]: #format.escape.sequences
-[format.fmt.string]: #format.fmt.string
-[format.formattable]: #format.formattable
-[format.formatter]: #format.formatter
-[format.formatter.spec]: #format.formatter.spec
-[format.functions]: #format.functions
-[format.parse.ctx]: #format.parse.ctx
-[format.range]: #format.range
-[format.range.fmtdef]: #format.range.fmtdef
-[format.range.fmtkind]: #format.range.fmtkind
-[format.range.fmtmap]: #format.range.fmtmap
-[format.range.fmtset]: #format.range.fmtset
-[format.range.fmtstr]: #format.range.fmtstr
-[format.range.formatter]: #format.range.formatter
-[format.sign]: #format.sign
-[format.string]: #format.string
-[format.string.escaped]: #format.string.escaped
-[format.string.general]: #format.string.general
-[format.string.std]: #format.string.std
-[format.syn]: #format.syn
-[format.tuple]: #format.tuple
-[format.type.bool]: #format.type.bool
-[format.type.char]: #format.type.char
-[format.type.float]: #format.type.float
-[format.type.int]: #format.type.int
-[format.type.ptr]: #format.type.ptr
-[format.type.string]: #format.type.string
-[formatter]: #formatter
-[formatter.basic]: #formatter.basic
-[formatter.range.type]: #formatter.range.type
-[formatter.requirements]: #formatter.requirements
-[formatter.tuple.type]: #formatter.tuple.type
 [forward]: #forward
 [freestanding.item]: library.md#freestanding.item
 [func.bind]: #func.bind
 [func.bind.bind]: #func.bind.bind
 [func.bind.general]: #func.bind.general
@@ -12875,10 +11635,16 @@ Otherwise, `endian::native` is not equal to either `endian::big` or
 [func.search.bmh]: #func.search.bmh
 [func.search.default]: #func.search.default
 [func.search.general]: #func.search.general
 [func.wrap]: #func.wrap
 [func.wrap.badcall]: #func.wrap.badcall
 [func.wrap.func]: #func.wrap.func
 [func.wrap.func.alg]: #func.wrap.func.alg
 [func.wrap.func.cap]: #func.wrap.func.cap
 [func.wrap.func.con]: #func.wrap.func.con
 [func.wrap.func.general]: #func.wrap.func.general
@@ -12891,27 +11657,34 @@ Otherwise, `endian::native` is not equal to either `endian::big` or
 [func.wrap.move.class]: #func.wrap.move.class
 [func.wrap.move.ctor]: #func.wrap.move.ctor
 [func.wrap.move.general]: #func.wrap.move.general
 [func.wrap.move.inv]: #func.wrap.move.inv
 [func.wrap.move.util]: #func.wrap.move.util
 [function.objects]: #function.objects
 [function.objects.general]: #function.objects.general
 [functional.syn]: #functional.syn
 [intro.multithread]: basic.md#intro.multithread
 [intro.object]: basic.md#intro.object
 [invalid.argument]: diagnostics.md#invalid.argument
 [istream.formatted]: input.md#istream.formatted
-[iterator.concept.output]: iterators.md#iterator.concept.output
-[lex.string.literal]: lex.md#lex.string.literal
 [logical.operations]: #logical.operations
 [logical.operations.and]: #logical.operations.and
 [logical.operations.general]: #logical.operations.general
 [logical.operations.not]: #logical.operations.not
 [logical.operations.or]: #logical.operations.or
 [meta.rqmts]: meta.md#meta.rqmts
 [meta.trans.other]: meta.md#meta.trans.other
-[namespace.std]: library.md#namespace.std
 [optional]: #optional
 [optional.assign]: #optional.assign
 [optional.assign.copy]: #optional.assign.copy
 [optional.assign.copy.templ]: #optional.assign.copy.templ
 [optional.assign.move]: #optional.assign.move
@@ -12920,17 +11693,28 @@ Otherwise, `endian::native` is not equal to either `endian::big` or
 [optional.comp.with.t]: #optional.comp.with.t
 [optional.ctor]: #optional.ctor
 [optional.dtor]: #optional.dtor
 [optional.general]: #optional.general
 [optional.hash]: #optional.hash
 [optional.mod]: #optional.mod
 [optional.monadic]: #optional.monadic
 [optional.nullops]: #optional.nullops
 [optional.nullopt]: #optional.nullopt
 [optional.observe]: #optional.observe
 [optional.optional]: #optional.optional
 [optional.optional.general]: #optional.optional.general
 [optional.relops]: #optional.relops
 [optional.specalg]: #optional.specalg
 [optional.swap]: #optional.swap
 [optional.syn]: #optional.syn
 [ostream.formatted]: input.md#ostream.formatted
@@ -12941,36 +11725,38 @@ Otherwise, `endian::native` is not equal to either `endian::big` or
 [pair.piecewise]: #pair.piecewise
 [pairs]: #pairs
 [pairs.general]: #pairs.general
 [pairs.pair]: #pairs.pair
 [pairs.spec]: #pairs.spec
 [range.cmp]: #range.cmp
 [range.utility.helpers]: ranges.md#range.utility.helpers
 [refwrap]: #refwrap
 [refwrap.access]: #refwrap.access
 [refwrap.assign]: #refwrap.assign
 [refwrap.common.ref]: #refwrap.common.ref
 [refwrap.const]: #refwrap.const
 [refwrap.general]: #refwrap.general
 [refwrap.helpers]: #refwrap.helpers
 [refwrap.invoke]: #refwrap.invoke
-[res.on.exception.handling]: library.md#res.on.exception.handling
-[round.style]: support.md#round.style
 [support.signal]: support.md#support.signal
 [swappable.requirements]: library.md#swappable.requirements
-[temp.param]: temp.md#temp.param
 [temp.type]: temp.md#temp.type
 [template.bitset]: #template.bitset
 [template.bitset.general]: #template.bitset.general
 [term.object.representation]: basic.md#term.object.representation
 [term.object.type]: basic.md#term.object.type
 [term.odr.use]: basic.md#term.odr.use
 [term.perfect.forwarding.call.wrapper]: #term.perfect.forwarding.call.wrapper
 [term.simple.call.wrapper]: #term.simple.call.wrapper
 [term.trivially.copyable.type]: basic.md#term.trivially.copyable.type
 [term.unevaluated.operand]: expr.md#term.unevaluated.operand
-[time.format]: time.md#time.format
 [tuple]: #tuple
 [tuple.apply]: #tuple.apply
 [tuple.assign]: #tuple.assign
 [tuple.cnstr]: #tuple.cnstr
 [tuple.common.ref]: #tuple.common.ref
@@ -12983,15 +11769,11 @@ Otherwise, `endian::native` is not equal to either `endian::big` or
 [tuple.special]: #tuple.special
 [tuple.swap]: #tuple.swap
 [tuple.syn]: #tuple.syn
 [tuple.traits]: #tuple.traits
 [tuple.tuple]: #tuple.tuple
-[type.index]: #type.index
-[type.index.hash]: #type.index.hash
-[type.index.members]: #type.index.members
-[type.index.overview]: #type.index.overview
-[type.index.synopsis]: #type.index.synopsis
 [unord]: containers.md#unord
 [unord.hash]: #unord.hash
 [utilities]: #utilities
 [utilities.general]: #utilities.general
 [utilities.summary]: #utilities.summary
@@ -12999,12 +11781,12 @@ Otherwise, `endian::native` is not equal to either `endian::big` or
 [utility.as.const]: #utility.as.const
 [utility.exchange]: #utility.exchange
 [utility.intcmp]: #utility.intcmp
 [utility.swap]: #utility.swap
 [utility.syn]: #utility.syn
 [utility.underlying]: #utility.underlying
-[utility.unreachable]: #utility.unreachable
 [variant]: #variant
 [variant.assign]: #variant.assign
 [variant.bad.access]: #variant.bad.access
 [variant.ctor]: #variant.ctor
 [variant.dtor]: #variant.dtor
@@ -13025,10 +11807,5 @@ Otherwise, `endian::native` is not equal to either `endian::big` or
 [variant.visit]: #variant.visit
 [^1]: Such a type is a function pointer or a class type which has a
     member `operator()` or a class type which has a conversion to a
     pointer to function.
-[^2]: Windows® is a registered trademark of Microsoft Corporation. This
-    information is given for the convenience of users of this document
-    and does not constitute an endorsement by ISO or IEC of this
-    product.

 [[utilities.summary]].
 **Table: General utilities library summary** <a id="utilities.summary">[utilities.summary]</a>
 | Subclause            |                              | Header         |
+| -------------------- | ---------------------------- | -------------- |
 | [[utility]]          | Utility components           | `<utility>`    |
 | [[pairs]]            | Pairs                        |                |
 | [[tuple]]            | Tuples                       | `<tuple>`      |
 | [[optional]]         | Optional objects             | `<optional>`   |
 | [[variant]]          | Variants                     | `<variant>`    |
 | [[any]]              | Storage for any type         | `<any>`        |
 | [[expected]]         | Expected objects             | `<expected>`   |
 | [[bitset]]           | Fixed-size sequences of bits | `<bitset>`     |
 | [[function.objects]] | Function objects             | `<functional>` |
 | [[bit]]              | Bit manipulation             | `<bit>`        |
 ## Utility components <a id="utility">[[utility]]</a>
   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, class U>
+    constexpr auto forward_like(U&& x) noexcept -> see below;
   template<class T>
     constexpr remove_reference_t<T>&& move(T&&) noexcept;
   template<class T>
     constexpr conditional_t<
         !is_nothrow_move_constructible_v<T> && is_copy_constructible_v<T>, const T&, T&&>
   // [utility.underlying], to_underlying
   template<class T>
     constexpr underlying_type_t<T> to_underlying(T value) noexcept;
+  // [utility.undefined], undefined behavior
   [[noreturn]] void unreachable();
+  void observable_checkpoint() noexcept;
   // [intseq], compile-time integer sequences%
 %
 %
   template<size_t I>
     struct in_place_index_t {
       explicit in_place_index_t() = default;
     };
   template<size_t I> constexpr in_place_index_t<I> in_place_index{};
+  // nontype argument tag%
+%
+  template<auto V>
+    struct nontype_t {
+      explicit nontype_t() = default;
+    };
+  template<auto V> constexpr nontype_t<V> nontype{};
+  // [variant.monostate], class monostate%
+  struct monostate;
+  // [variant.monostate.relops], monostate relational operators%
+{monostate{monostate}
+  constexpr bool operator==(monostate, monostate) noexcept;
+  constexpr strong_ordering operator<=>(monostate, monostate) noexcept;
+  // [variant.hash], hash support%
+{monostate}
+  template<class T> struct hash;
+  template<> struct hash<monostate>;
 }
 ```
 ### `swap` <a id="utility.swap">[[utility.swap]]</a>
 — *end example*]
 ``` cpp
 template<class T, class U>
+  constexpr auto forward_like(U&& x) noexcept -> see below;
 ```
 *Mandates:* `T` is a referenceable type [[defns.referenceable]].
 - Let *`COPY_CONST`*`(A, B)` be `const B` if `A` is a const type,
   constexpr underlying_type_t<T> to_underlying(T value) noexcept;
 ```
 *Returns:* `static_cast<underlying_type_t<T>>(value)`.
+### Undefined behavior <a id="utility.undefined">[[utility.undefined]]</a>
 ``` cpp
 [[noreturn]] void unreachable();
 ```
 int b = f(3);           // undefined behavior
 ```
 — *end example*]
+``` cpp
+void observable_checkpoint() noexcept;
+```
+*Effects:* Establishes an observable checkpoint [[intro.abstract]].
 ## Pairs <a id="pairs">[[pairs]]</a>
+### General <a id="pairs.general">[[pairs.general]]</a>
 The library provides a template for heterogeneous pairs of values. The
 library also provides a matching function template to simplify their
 construction and several templates that provide access to `pair` objects
 as if they were `tuple` objects (see  [[tuple.helper]] and
   template<class T1, class T2>
     pair(T1, T2) -> pair<T1, T2>;
 }
 ```
+Member functions of `pair` do 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` is a
 constexpr function if and only if all required element-wise
 initializations for move and copy, respectively, would be
 constexpr-suitable [[dcl.constexpr]].
 If
 `(is_trivially_destructible_v<T1> && is_trivially_destructible_v<T2>)`
 is `true`, then the destructor of `pair` is trivial.
+`pair<T, U>` is a structural type [[term.structural.type]] if `T` and
+`U` are both structural types. Two values `p1` and `p2` of type
+`pair<T, U>` are template-argument-equivalent [[temp.type]] if and only
+if `p1.first` and `p2.first` are template-argument-equivalent and
+`p1.second` and `p2.second` are template-argument-equivalent.
 ``` cpp
 constexpr explicit(see below) pair();
 ```
 *Constraints:*
 - `is_move_assignable_v<T1>` is `true` and
 - `is_move_assignable_v<T2>` is `true`.
+*Effects:* Assigns `std::forward<T1>(p.first)` to `first` and
+`std::forward<T2>(p.second)` to `second`.
 *Returns:* `*this`.
 *Remarks:* The exception specification is equivalent to:
 *Constraints:*
 - `is_assignable_v<T1&, U1>` is `true` and
 - `is_assignable_v<T2&, U2>` is `true`.
+*Effects:* Assigns `std::forward<U1>(p.first)` `first` and
+`std::forward<U2>(p.second)` to `second`.
 *Returns:* `*this`.
 ``` cpp
 template<pair-like P> constexpr pair& operator=(P&& p);
 ``` cpp
 template<class T1, class T2, class U1, class U2>
   constexpr bool operator==(const pair<T1, T2>& x, const pair<U1, U2>& y);
 ```
+*Constraints:* `x.first == y.first` and `x.second == y.second` are valid
+expressions and each of `decltype(x.first == y.first)` and
+`decltype(x.second == y.second)` models *`boolean- testable`*.
 *Returns:* `x.first == y.first && x.second == y.second`.
 ``` cpp
 template<class T1, class T2, class U1, class U2>
   };
 ```
 *Mandates:* `I` < 2.
+*Result:* The type `T1` if `I` is 0, otherwise 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>
 arguments used for piecewise construction of the elements of the `pair`
 object.
 ## Tuples <a id="tuple">[[tuple]]</a>
+### General <a id="tuple.general">[[tuple.general]]</a>
 Subclause  [[tuple]] describes the tuple library that provides a tuple
 type as the class template `tuple` that can be instantiated with any
 number of arguments. Each template argument specifies the type of an
 element in the `tuple`. Consequently, tuples are heterogeneous,
 fixed-size collections of values. An instantiation of `tuple` with two
 arguments is similar to an instantiation of `pair` with the same two
 arguments. See  [[pairs]].
+In addition to being available via inclusion of the `<tuple>` header,
+`ignore` [[tuple.syn]] is available when `<utility>` [[utility]] is
+included.
 ### Header `<tuple>` synopsis <a id="tuple.syn">[[tuple.syn]]</a>
 ``` cpp
 // all freestanding
 #include <compare>              // see [compare.syn]
            template<class> class TQual, template<class> class UQual>
     struct basic_common_reference<TTuple, UTuple, TQual, UQual>;
   template<exposition onlyconceptnc{tuple-like} TTuple, exposition onlyconceptnc{tuple-like} UTuple>
     struct common_type<TTuple, UTuple>;
+  // ignore
+  struct ignore-type {                      // exposition only
+    constexpr const ignore-type&
+      operator=(const auto &) const noexcept { return *this; }
+  };
+  inline constexpr ignore-type ignore;
   // [tuple.creation], tuple creation functions
   template<class... TTypes>
     constexpr tuple<unwrap_ref_decay_t<TTypes>...> make_tuple(TTypes&&...);
   template<class... TTypes>
     constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&...) noexcept;
   template<exposition onlyconceptnc{tuple-like}... Tuples>
     constexpr tuple<CTypes...> tuple_cat(Tuples&&...);
   // [tuple.apply], calling a function with a tuple of arguments
   template<class F, exposition onlyconceptnc{tuple-like} Tuple>
+    constexpr apply_result_t<F, Tuple> apply(F&& f, Tuple&& t)
+      noexcept(is_nothrow_applicable_v<F, Tuple>);
   template<class T, exposition onlyconceptnc{tuple-like} Tuple>
     constexpr T make_from_tuple(Tuple&& t);
   // [tuple.helper], tuple helper classes
   template<size_t I, class... Types>
     struct tuple_element<I, tuple<Types...>>;
   template<size_t I, class T>
+    using tuple_element_t = 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>
 template<class T>
   concept tuple-like = see belownc;           // exposition only
 ```
 A type `T` models and satisfies the exposition-only concept `tuple-like`
+if `remove_cvref_t<T>` is a specialization of `array`, `complex`,
+`pair`, `tuple`, or `ranges::subrange`.
 ### Class template `tuple` <a id="tuple.tuple">[[tuple.tuple]]</a>
+#### General <a id="tuple.tuple.general">[[tuple.tuple.general]]</a>
 ``` cpp
 namespace std {
   template<class... Types>
   class tuple {
   public:
   template<class Alloc, class... UTypes>
     tuple(allocator_arg_t, Alloc, tuple<UTypes...>) -> tuple<UTypes...>;
 }
 ```
+If a program declares an explicit or partial specialization of `tuple`,
+the program is ill-formed, no diagnostic required.
 #### Construction <a id="tuple.cnstr">[[tuple.cnstr]]</a>
 In the descriptions that follow, let i be in the range \[`0`,
 `sizeof...(Types)`) in order, `Tᵢ` be the iᵗʰ type in `Types`, and `Uᵢ`
 be the iᵗʰ type in a template parameter pack named `UTypes`, where
 template<class... UTypes> constexpr explicit(see below) tuple(const tuple<UTypes...>& u);
 template<class... UTypes> constexpr explicit(see below) tuple(tuple<UTypes...>&& u);
 template<class... UTypes> constexpr explicit(see below) tuple(const tuple<UTypes...>&& u);
 ```
+Let `I` be the pack `0, 1, `…`, (sizeof...(Types) - 1)`. Let
 *`FWD`*`(u)` be `static_cast<decltype(u)>(u)`.
 *Constraints:*
 - `sizeof...(Types)` equals `sizeof...(UTypes)`, and
 ``` cpp
 template<tuple-like UTuple>
   constexpr explicit(see below) tuple(UTuple&& u);
 ```
+Let `I` be the pack `0, 1, `…`, (sizeof...(Types) - 1)`.
 *Constraints:*
 - `different-from<UTuple, tuple>` [[range.utility.helpers]] is `true`,
 - `remove_cvref_t<UTuple>` is not a specialization of
   `ranges::subrange`,
 - `sizeof...(Types)` equals `tuple_size_v<remove_cvref_t<UTuple>>`,
 - `(is_constructible_v<Types, decltype(get<I>(std::forward<UTuple>(u)))> && ...)`
   is `true`, and
+- either `sizeof...(Types)` is not 1, or (when `Types...` expands to
   `T`) `is_convertible_v<UTuple, T>` and `is_constructible_v<T, UTuple>`
   are both `false`.
 *Effects:* For all i, initializes the iᵗʰ element of `*this` with
 `get<`i`>(std::forward<UTuple>(u))`.
 ``` cpp
 !(is_convertible_v<decltype(get<I>(std::forward<UTuple>(u))), Types> && ...)
 ```
+The constructor is defined as deleted if
+``` cpp
+(reference_constructs_from_temporary_v<Types, decltype(get<I>(std::forward<UTuple>(u)))>
+ || ...)
+```
+is `true`.
 ``` cpp
 template<class Alloc>
   constexpr explicit(see below)
     tuple(allocator_arg_t, const Alloc& a);
 template<class Alloc>
 *Constraints:*
 - `different-from<UTuple, tuple>` [[range.utility.helpers]] is `true`,
 - `remove_cvref_t<UTuple>` is not a specialization of
   `ranges::subrange`,
+- `sizeof...(Types)` equals `tuple_size_v<remove_cvref_t<UTuple>>`, and
 - `is_assignable_v<``Tᵢ``&, decltype(get<`i`>(std::forward<UTuple>(u)))>`
   is `true` for all i.
 *Effects:* For all i, assigns `get<`i`>(std::forward<UTuple>(u))` to
 `get<`i`>(*this)`.
 *Constraints:*
 - `different-from<UTuple, tuple>` [[range.utility.helpers]] is `true`,
 - `remove_cvref_t<UTuple>` is not a specialization of
   `ranges::subrange`,
+- `sizeof...(Types)` equals `tuple_size_v<remove_cvref_t<UTuple>>`, and
 - `is_assignable_v<const ``Tᵢ``&, decltype(get<`i`>(std::forward<UTuple>(u)))>`
   is `true` for all i.
 *Effects:* For all i, assigns `get<`i`>(std::forward<UTuple>(u))` to
 `get<`i`>(*this)`.
   `true`.
 *Preconditions:* For all i, `get<`i`>(*this)` is swappable
 with [[swappable.requirements]] `get<`i`>(rhs)`.
+*Effects:* For each i, calls `swap` for `get<`i`>(*this)` and
 `get<`i`>(rhs)`.
 *Throws:* Nothing unless one of the element-wise `swap` calls throws an
 exception.
 ``` cpp
 template<class... TTypes>
   constexpr tuple<TTypes&...> tie(TTypes&... t) noexcept;
 ```
+*Returns:* `tuple<TTypes&...>(t...)`.
 [*Example 2*:
 `tie` functions allow one to create tuples that unpack tuples into
 variables. `ignore` can be used for elements that are not needed:
 ### Calling a function with a `tuple` of arguments <a id="tuple.apply">[[tuple.apply]]</a>
 ``` cpp
 template<class F, tuple-like Tuple>
+  constexpr apply_result_t<F, Tuple> apply(F&& f, Tuple&& t)
+    noexcept(is_nothrow_applicable_v<F, Tuple>);
 ```
+*Effects:* Given the exposition-only function template:
 ``` cpp
 namespace std {
   template<class F, tuple-like Tuple, size_t... I>
   constexpr decltype(auto) apply-impl(F&& f, Tuple&& t, index_sequence<I...>) {
 ``` cpp
 return apply-impl(std::forward<F>(f), std::forward<Tuple>(t),
                   make_index_sequence<tuple_size_v<remove_reference_t<Tuple>>>{});
 ```
 ``` cpp
 template<class T, tuple-like Tuple>
   constexpr T make_from_tuple(Tuple&& t);
 ```
 *Mandates:* If `tuple_size_v<remove_reference_t<Tuple>>` is 1, then
 `reference_constructs_from_temporary_v<T, decltype(get<0>(declval<Tuple>()))>`
 is `false`.
+*Effects:* Given the exposition-only function template:
 ``` cpp
 namespace std {
   template<class T, tuple-like Tuple, size_t... I>
     requires is_constructible_v<T, decltype(get<I>(declval<Tuple>()))...>
 ``` cpp
 template<class T> struct tuple_size;
 ```
+Except where specified otherwise, all specializations of `tuple_size`
+meet the *Cpp17UnaryTypeTrait* requirements [[meta.rqmts]] with a base
+characteristic of `integral_constant<size_t, N>` for some `N`.
 ``` cpp
 template<class... Types>
+  struct tuple_size<tuple<Types...>> : integral_constant<size_t, sizeof...(Types)> { };
 ```
 ``` cpp
 template<size_t I, class... Types>
   struct tuple_element<I, tuple<Types...>> {
   };
 ```
 *Mandates:* `I` < `sizeof...(Types)`.
+*Result:* `TI` is the type of the `I`ᵗʰ element of `Types`, where
+indexing is zero-based.
 ``` cpp
 template<class T> struct tuple_size<const T>;
 ```
 ```
 Let `TE` denote `tuple_element_t<I, T>` of the cv-unqualified type `T`.
 Then each specialization of the template meets the
 *Cpp17TransformationTrait* requirements [[meta.rqmts]] with a member
+typedef `type` that names the type `const TE`.
 In addition to being available via inclusion of the `<tuple>` header,
 the template is available when any of the headers `<array>`, `<ranges>`,
 or `<utility>` are included.
 template<size_t I, class... Types>
   constexpr tuple_element_t<I, tuple<Types...>>&
     get(tuple<Types...>& t) noexcept;
 template<size_t I, class... Types>
   constexpr tuple_element_t<I, tuple<Types...>>&&
+    get(tuple<Types...>&& t) noexcept;        // #1
 template<size_t I, class... Types>
   constexpr const tuple_element_t<I, tuple<Types...>>&
+    get(const tuple<Types...>& t) noexcept;   // #2
 template<size_t I, class... Types>
   constexpr const tuple_element_t<I, tuple<Types...>>&& get(const tuple<Types...>&& t) noexcept;
 ```
 *Mandates:* `I` < `sizeof...(Types)`.
 *Returns:* A reference to the `I`ᵗʰ element of `t`, where indexing is
 zero-based.
+[*Note 1*: For the overload marked \#1, if a type `T` in `Types` is
+some reference type `X&`, the return type is `X&`, not `X&&`. However,
+if the element type is a non-reference type `T`, the return type is
+`T&&`. — *end note*]
+[*Note 2*: Constness is shallow. For the overload marked \#2, if a type
+`T` in `Types` is some reference type `X&`, the return type is `X&`, not
+`const X&`. However, if the element type is a non-reference type `T`,
+the return type is `const T&`. This is consistent with how constness is
+defined to work for non-static data members of reference
+type. — *end note*]
 ``` cpp
 template<class T, class... Types>
   constexpr T& get(tuple<Types...>& t) noexcept;
 template<class T, class... Types>
   constexpr bool operator==(const tuple<TTypes...>& t, const UTuple& u);
 ```
 For the first overload let `UTuple` be `tuple<UTypes...>`.
+*Constraints:* For all `i`, where 0 ≤ `i` < `sizeof...(TTypes)`,
+`get<i>(t) == get<i>(u)` is a valid expression and
+`decltype(get<i>(t) == get<i>(u))` models `boolean-testable`.
+`sizeof...(TTypes)` equals `tuple_size_v<UTuple>`.
 *Returns:* `true` if `get<i>(t) == get<i>(u)` for all `i`, otherwise
 `false`.
 [*Note 1*: If `sizeof...(TTypes)` equals zero, returns
 [*Note 1*: The above definition does not require `tₜₐᵢₗ` (or `uₜₐᵢₗ`)
 to be constructed. It might not even be possible, as `t` and `u` are not
 required to be copy constructible. Also, all comparison operator
 functions are short circuited; they do not perform element accesses
+beyond what is needed to determine the result of the
 comparison. — *end note*]
 ### `common_reference` related specializations <a id="tuple.common.ref">[[tuple.common.ref]]</a>
 In the descriptions that follow:
 - `is_same_v<UTuple, decay_t<UTuple>>` is `true`.
 - `tuple_size_v<TTuple>` equals `tuple_size_v<UTuple>`.
 - `tuple<common_reference_t<TQual<TTypes>, UQual<UTypes>>...>` denotes a
   type.
+*Result:* The member *typedef-name* `type` denotes the type
 `tuple<common_reference_t<TQual<TTypes>, UQual<UTypes>>...>`.
 ``` cpp
 template<tuple-like TTuple, tuple-like UTuple>
 struct common_type<TTuple, UTuple> {
 - `is_same_v<TTuple, decay_t<TTuple>>` is `true`.
 - `is_same_v<UTuple, decay_t<UTuple>>` is `true`.
 - `tuple_size_v<TTuple>` equals `tuple_size_v<UTuple>`.
 - `tuple<common_type_t<TTypes, UTypes>...>` denotes a type.
+*Result:* The member *typedef-name* `type` denotes the type
 `tuple<common_type_t<TTypes, UTypes>...>`.
 ### Tuple traits <a id="tuple.traits">[[tuple.traits]]</a>
 ``` cpp
 noexcept(x.swap(y))
 ```
 ## Optional objects <a id="optional">[[optional]]</a>
+### General <a id="optional.general">[[optional.general]]</a>
 Subclause  [[optional]] describes class template `optional` that
 represents optional objects. An *optional object* is an object that
 contains the storage for another object and manages the lifetime of this
 contained object, if any. The contained object may be initialized after
 contained object is tracked by the optional object.
 ### Header `<optional>` synopsis <a id="optional.syn">[[optional.syn]]</a>
 ``` cpp
+// mostly freestanding
 #include <compare>              // see [compare.syn]
 namespace std {
   // [optional.optional], class template optional
   template<class T>
+    class optional;                                             // partially freestanding
+  // [optional.optional.ref], partial specialization of optional for lvalue reference types
+  template<class T>
+    class optional<T&>;                                         // partially freestanding
+  template<class T>
+    constexpr bool ranges::enable_view<optional<T>> = true;
+  template<class T>
+    constexpr auto format_kind<optional<T>> = range_format::disabled;
+  template<class T>
+    constexpr bool ranges::enable_borrowed_range<optional<T&>> = true;
   template<class T>
     concept is-derived-from-optional = requires(const T& t) {   // exposition only
       []<class U>(const optional<U>&){ }(t);
     };
   // [optional.specalg], specialized algorithms
   template<class T>
     constexpr void swap(optional<T>&, optional<T>&) noexcept(see below);
   template<class T>
+    constexpr optional<decay_t<T>> make_optional(T&&);
   template<class T, class... Args>
     constexpr optional<T> make_optional(Args&&... args);
   template<class T, class U, class... Args>
     constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args);
 namespace std {
   template<class T>
   class optional {
   public:
     using value_type     = T;
+    using iterator       = implementation-defined;              // see~[optional.iterators]
+    using const_iterator = implementation-defined;              // see~[optional.iterators]
     // [optional.ctor], constructors
     constexpr optional() noexcept;
     constexpr optional(nullopt_t) noexcept;
     constexpr optional(const optional&);
     constexpr optional(optional&&) noexcept(see below);
     template<class... Args>
       constexpr explicit optional(in_place_t, Args&&...);
     template<class U, class... Args>
       constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
+    template<class U = remove_cv_t<T>>
       constexpr explicit(see below) optional(U&&);
     template<class U>
       constexpr explicit(see below) optional(const optional<U>&);
     template<class U>
       constexpr explicit(see below) optional(optional<U>&&);
     // [optional.assign], assignment
     constexpr optional& operator=(nullopt_t) noexcept;
     constexpr optional& operator=(const optional&);
     constexpr optional& operator=(optional&&) noexcept(see below);
+    template<class U = remove_cv_t<T>> constexpr optional& operator=(U&&);
     template<class U> constexpr optional& operator=(const optional<U>&);
     template<class U> constexpr optional& operator=(optional<U>&&);
     template<class... Args> constexpr T& emplace(Args&&...);
     template<class U, class... Args> constexpr T& emplace(initializer_list<U>, Args&&...);
     // [optional.swap], swap
     constexpr void swap(optional&) noexcept(see below);
+    // [optional.iterators], iterator support
+    constexpr iterator begin() noexcept;
+    constexpr const_iterator begin() const noexcept;
+    constexpr iterator end() noexcept;
+    constexpr const_iterator end() const noexcept;
     // [optional.observe], observers
     constexpr const T* operator->() const noexcept;
     constexpr T* operator->() noexcept;
     constexpr const T& operator*() const & noexcept;
     constexpr T& operator*() & noexcept;
     constexpr T&& operator*() && noexcept;
     constexpr const T&& operator*() const && noexcept;
     constexpr explicit operator bool() const noexcept;
     constexpr bool has_value() const noexcept;
+    constexpr const T& value() const &;                                 // freestanding-deleted
+    constexpr T& value() &;                                             // freestanding-deleted
+    constexpr T&& value() &&;                                           // freestanding-deleted
+    constexpr const T&& value() const &&;                               // freestanding-deleted
+    template<class U = remove_cv_t<T>> constexpr T value_or(U&&) const &;
+    template<class U = remove_cv_t<T>> constexpr T value_or(U&&) &&;
     // [optional.monadic], monadic operations
     template<class F> constexpr auto and_then(F&& f) &;
     template<class F> constexpr auto and_then(F&& f) &&;
     template<class F> constexpr auto and_then(F&& f) const &;
   template<class T>
     optional(T) -> optional<T>;
 }
 ```
+An object of type `optional<T>` at any given time either contains a
+value or does not contain a value. When an object of type `optional<T>`
+*contains a value*, it means that an object of type `T`, referred to as
+the optional object’s *contained value*, is nested within
+[[intro.object]] the optional object. When an object of type
+`optional<T>` is contextually converted to `bool`, the conversion
+returns `true` if the object contains a value; otherwise the conversion
+returns `false`.
+When an object of type `optional<T>` contains a value, member `val`
+points to the contained value.
+A type `X` is a *valid contained type* for `optional` if `X` is an
+lvalue reference type or a complete non-array object type, and
+`remove_cvref_t<X>` is a type other than `in_place_t` or `nullopt_t`. If
+a specialization of `optional` is instantiated with a type `T` that is
+not a valid contained type for `optional`, the program is ill-formed. If
+`T` is an object type, `T` shall meet the *Cpp17Destructible*
+requirements ([[cpp17.destructible]]).
 #### Constructors <a id="optional.ctor">[[optional.ctor]]</a>
 The exposition-only variable template *`converts-from-any-cvref`* is
 used by some constructors for `optional`.
 ```
 *Constraints:* `is_move_constructible_v<T>` is `true`.
 *Effects:* If `rhs` contains a value, direct-non-list-initializes the
+contained value with `*std::move(rhs)`. `rhs.has_value()` is unchanged.
 *Ensures:* `rhs.has_value() == this->has_value()`.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 *Remarks:* If `T`’s constructor selected for the initialization is a
 constexpr constructor, this constructor is a constexpr constructor.
 ``` cpp
+template<class U = remove_cv_t<T>> constexpr explicit(see below) optional(U&& v);
 ```
 *Constraints:*
 - `is_constructible_v<T, U>` is `true`,
 - `is_constructible_v<T, U>` is `true`, and
 - if `T` is not cv `bool`, *`converts-from-any-cvref`*`<T, optional<U>>`
   is `false`.
 *Effects:* If `rhs` contains a value, direct-non-list-initializes the
+contained value with `*std::move(rhs)`. `rhs.has_value()` is unchanged.
 *Ensures:* `rhs.has_value() == this->has_value()`.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 **Table: `optional::operator=(optional&&)` effects** <a id="optional.assign.move">[optional.assign.move]</a>
 |                                | `*this` contains a value                               | `*this` does not contain a value                                       |
 | ------------------------------ | ------------------------------------------------------ | ---------------------------------------------------------------------- |
+| `rhs` contains a value         | assigns `*std::move(rhs)` to the contained value       | direct-non-list-initializes the contained value with `*std::move(rhs)` |
 | `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                              |
 *Ensures:* `rhs.has_value() == this->has_value()`.
 `is_trivially_move_constructible_v<T> &&`
 `is_trivially_move_assignable_v<T> &&` `is_trivially_destructible_v<T>`
 is `true`, this assignment operator is trivial.
 ``` cpp
+template<class U = remove_cv_t<T>> constexpr optional& operator=(U&& v);
 ```
+*Constraints:*
+- `is_same_v<remove_cvref_t<U>, optional>` is `false`,
+- `conjunction_v<is_scalar<T>, is_same<T, decay_t<U>>>` is `false`,
+- `is_constructible_v<T, U>` is `true`, and
+- `is_assignable_v<T&, U>` is `true`.
 *Effects:* If `*this` contains a value, assigns `std::forward<U>(v)` to
 the contained value; otherwise direct-non-list-initializes the contained
 value with `std::forward<U>(v)`.
 **Table: `optional::operator=(optional<U>&&)` effects** <a id="optional.assign.move.templ">[optional.assign.move.templ]</a>
 |                                | `*this` contains a value                               | `*this` does not contain a value                                       |
 | ------------------------------ | ------------------------------------------------------ | ---------------------------------------------------------------------- |
+| `rhs` contains a value         | assigns `*std::move(rhs)` to the contained value       | direct-non-list-initializes the contained value with `*std::move(rhs)` |
 | `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                              |
 *Ensures:* `rhs.has_value() == this->has_value()`.
 `*val` and `*rhs.val` is determined by the exception safety guarantee of
 `swap` for lvalues of `T`. If an exception is thrown during the call to
 `T`’s move constructor, the state of `*val` and `*rhs.val` is determined
 by the exception safety guarantee of `T`’s move constructor.
+#### Iterator support <a id="optional.iterators">[[optional.iterators]]</a>
+``` cpp
+using iterator       = implementation-defined;
+using const_iterator = implementation-defined;
+```
+These types model `contiguous_iterator` [[iterator.concept.contiguous]],
+meet the *Cpp17RandomAccessIterator*
+requirements [[random.access.iterators]], and meet the requirements for
+constexpr iterators [[iterator.requirements.general]], with value type
+`remove_cv_t<T>`. The reference type is `T&` for `iterator` and
+`const T&` for `const_iterator`.
+All requirements on container iterators [[container.reqmts]] apply to
+`optional::iterator` and `optional::const_iterator` as well.
+Any operation that initializes or destroys the contained value of an
+optional object invalidates all iterators into that object.
+``` cpp
+constexpr iterator begin() noexcept;
+constexpr const_iterator begin() const noexcept;
+```
+*Returns:* If `has_value()` is `true`, an iterator referring to the
+contained value. Otherwise, a past-the-end iterator value.
+``` cpp
+constexpr iterator end() noexcept;
+constexpr const_iterator end() const noexcept;
+```
+*Returns:* `begin() + has_value()`.
 #### Observers <a id="optional.observe">[[optional.observe]]</a>
 ``` cpp
 constexpr const T* operator->() const noexcept;
 constexpr T* operator->() noexcept;
 ```
+`has_value()` is `true`.
 *Returns:* `val`.
 *Remarks:* These functions are constexpr functions.
 ``` cpp
 constexpr const T& operator*() const & noexcept;
 constexpr T& operator*() & noexcept;
 ```
+`has_value()` is `true`.
 *Returns:* `*val`.
 *Remarks:* These functions are constexpr functions.
 ``` cpp
 constexpr T&& operator*() && noexcept;
 constexpr const T&& operator*() const && noexcept;
 ```
+`has_value()` is `true`.
 *Effects:* Equivalent to: `return std::move(*val);`
 ``` cpp
 constexpr explicit operator bool() const noexcept;
 ``` cpp
 return has_value() ? std::move(*val) : throw bad_optional_access();
 ```
 ``` cpp
+template<class U = remove_cv_t<T>> constexpr T value_or(U&& v) const &;
 ```
 *Mandates:* `is_copy_constructible_v<T> && is_convertible_v<U&&, T>` is
 `true`.
 ``` cpp
 return has_value() ? **this : static_cast<T>(std::forward<U>(v));
 ```
 ``` cpp
+template<class U = remove_cv_t<T>> constexpr T value_or(U&& v) &&;
 ```
 *Mandates:* `is_move_constructible_v<T> && is_convertible_v<U&&, T>` is
 `true`.
 ``` cpp
 template<class F> constexpr auto and_then(F&& f) &;
 template<class F> constexpr auto and_then(F&& f) const &;
 ```
+Let `U` be `invoke_result_t<F, decltype(*`*`val`*`)>`.
 *Mandates:* `remove_cvref_t<U>` is a specialization of `optional`.
 *Effects:* Equivalent to:
 ``` cpp
 if (*this) {
+  return invoke(std::forward<F>(f), *val);
 } else {
   return remove_cvref_t<U>();
 }
 ```
 ``` cpp
 template<class F> constexpr auto and_then(F&& f) &&;
 template<class F> constexpr auto and_then(F&& f) const &&;
 ```
+Let `U` be `invoke_result_t<F, decltype(std::move(*`*`val`*`))>`.
 *Mandates:* `remove_cvref_t<U>` is a specialization of `optional`.
 *Effects:* Equivalent to:
 ``` cpp
 if (*this) {
+  return invoke(std::forward<F>(f), std::move(*val));
 } else {
   return remove_cvref_t<U>();
 }
 ```
 ``` cpp
 template<class F> constexpr auto transform(F&& f) &;
 template<class F> constexpr auto transform(F&& f) const &;
 ```
+Let `U` be `remove_cv_t<invoke_result_t<F, decltype(*`*`val`*`)>>`.
+*Mandates:* `U` is a valid contained type for `optional`. The
+declaration
 ``` cpp
+U u(invoke(std::forward<F>(f), *val));
 ```
 is well-formed for some invented variable `u`.
 [*Note 1*: There is no requirement that `U` is
 movable [[dcl.init.general]]. — *end note*]
 *Returns:* If `*this` contains a value, an `optional<U>` object whose
 contained value is direct-non-list-initialized with
+`invoke(std::forward<F>(f), *`*`val`*`)`; otherwise, `optional<U>()`.
 ``` cpp
 template<class F> constexpr auto transform(F&& f) &&;
 template<class F> constexpr auto transform(F&& f) const &&;
 ```
 Let `U` be
+`remove_cv_t<invoke_result_t<F, decltype(std::move(*`*`val`*`))>>`.
+*Mandates:* `U` is a valid contained type for `optional`. The
+declaration
 ``` cpp
+U u(invoke(std::forward<F>(f), std::move(*val)));
 ```
 is well-formed for some invented variable `u`.
 [*Note 2*: There is no requirement that `U` is
 movable [[dcl.init.general]]. — *end note*]
 *Returns:* If `*this` contains a value, an `optional<U>` object whose
 contained value is direct-non-list-initialized with
+`invoke(std::forward<F>(f), std::move(*`*`val`*`))`; otherwise,
 `optional<U>()`.
 ``` cpp
 template<class F> constexpr optional or_else(F&& f) const &;
 ```
+*Constraints:* `F` models `invocable` and `T` models
 `copy_constructible`.
 *Mandates:* `is_same_v<remove_cvref_t<invoke_result_t<F>>, optional>` is
 `true`.
 ``` cpp
 template<class F> constexpr optional or_else(F&& f) &&;
 ```
+*Constraints:* `F` models `invocable` and `T` models
 `move_constructible`.
 *Mandates:* `is_same_v<remove_cvref_t<invoke_result_t<F>>, optional>` is
 `true`.
 *Effects:* If `*this` contains a value, calls `val->T::T̃()` to destroy
 the contained value; otherwise no effect.
 *Ensures:* `*this` does not contain a value.
+### Partial specialization of `optional` for reference types <a id="optional.optional.ref">[[optional.optional.ref]]</a>
+#### General <a id="optional.optional.ref.general">[[optional.optional.ref.general]]</a>
+``` cpp
+namespace std {
+  template<class T>
+  class optional<T&> {
+  public:
+    using value_type     = T;
+    using iterator       = implementation-defined;              // see~[optional.ref.iterators]
+  public:
+    // [optional.ref.ctor], constructors
+    constexpr optional() noexcept = default;
+    constexpr optional(nullopt_t) noexcept : optional() {}
+    constexpr optional(const optional& rhs) noexcept = default;
+    template<class Arg>
+      constexpr explicit optional(in_place_t, Arg&& arg);
+    template<class U>
+      constexpr explicit(see below) optional(U&& u) noexcept(see below);
+    template<class U>
+      constexpr explicit(see below) optional(optional<U>& rhs) noexcept(see below);
+    template<class U>
+      constexpr explicit(see below) optional(const optional<U>& rhs) noexcept(see below);
+    template<class U>
+      constexpr explicit(see below) optional(optional<U>&& rhs) noexcept(see below);
+    template<class U>
+      constexpr explicit(see below) optional(const optional<U>&& rhs) noexcept(see below);
+    constexpr ~optional() = default;
+    // [optional.ref.assign], assignment
+    constexpr optional& operator=(nullopt_t) noexcept;
+    constexpr optional& operator=(const optional& rhs) noexcept = default;
+    template<class U> constexpr T& emplace(U&& u) noexcept(see below);
+    // [optional.ref.swap], swap
+    constexpr void swap(optional& rhs) noexcept;
+    // [optional.ref.iterators], iterator support
+    constexpr iterator begin() const noexcept;
+    constexpr iterator end() const noexcept;
+    // [optional.ref.observe], observers
+    constexpr T*       operator->() const noexcept;
+    constexpr T&       operator*() const noexcept;
+    constexpr explicit operator bool() const noexcept;
+    constexpr bool     has_value() const noexcept;
+    constexpr T&       value() const;                           // freestanding-deleted
+    template<class U = remove_cv_t<T>>
+      constexpr remove_cv_t<T> value_or(U&& u) const;
+    // [optional.ref.monadic], monadic operations
+    template<class F> constexpr auto and_then(F&& f) const;
+    template<class F> constexpr optional<invoke_result_t<F, T&>> transform(F&& f) const;
+    template<class F> constexpr optional or_else(F&& f) const;
+    // [optional.ref.mod], modifiers
+    constexpr void reset() noexcept;
+  private:
+    T* val = nullptr;                                           // exposition only
+    // [optional.ref.expos], exposition only helper functions
+    template<class U>
+      constexpr void convert-ref-init-val(U&& u);               // exposition only
+  };
+}
+```
+An object of type `optional<T&>` *contains a value* if and only if
+`val != nullptr` is `true`. When an `optional<T&>` contains a value, the
+*contained value* is a reference to `*val`.
+#### Constructors <a id="optional.ref.ctor">[[optional.ref.ctor]]</a>
+``` cpp
+template<class Arg>
+  constexpr explicit optional(in_place_t, Arg&& arg);
+```
+*Constraints:*
+- `is_constructible_v<T&, Arg>` is `true`, and
+- `reference_constructs_from_temporary_v<T&, Arg>` is `false`.
+*Effects:* Equivalent to:
+*`convert-ref-init-val`*`(std::forward<Arg>(arg))`.
+*Ensures:* `*this` contains a value.
+``` cpp
+template<class U>
+  constexpr explicit(!is_convertible_v<U, T&>)
+  optional(U&& u) noexcept(is_nothrow_constructible_v<T&, U>);
+```
+*Constraints:*
+- `is_same_v<remove_cvref_t<U>, optional>` is `false`,
+- `is_same_v<remove_cvref_t<U>, in_place_t>` is `false`, and
+- `is_constructible_v<T&, U>` is `true`.
+*Effects:* Equivalent to:
+*`convert-ref-init-val`*`(std::forward<U>(u))`.
+*Ensures:* `*this` contains a value.
+*Remarks:* This constructor is defined as deleted if
+``` cpp
+reference_constructs_from_temporary_v<T&, U>
+```
+is `true`.
+``` cpp
+template<class U>
+  constexpr explicit(!is_convertible_v<U&, T&>)
+  optional(optional<U>& rhs) noexcept(is_nothrow_constructible_v<T&, U&>);
+```
+*Constraints:*
+- `is_same_v<remove_cv_t<T>, optional<U>>` is `false`,
+- `is_same_v<T&, U>` is `false`, and
+- `is_constructible_v<T&, U&>` is `true`.
+*Effects:* Equivalent to:
+``` cpp
+if (rhs.has_value()) convert-ref-init-val(*rhs);
+```
+*Remarks:* This constructor is defined as deleted if
+``` cpp
+reference_constructs_from_temporary_v<T&, U&>
+```
+is `true`.
+``` cpp
+template<class U>
+  constexpr explicit(!is_convertible_v<const U&, T&>)
+  optional(const optional<U>& rhs) noexcept(is_nothrow_constructible_v<T&, const U&>);
+```
+*Constraints:*
+- `is_same_v<remove_cv_t<T>, optional<U>>` is `false`,
+- `is_same_v<T&, U>` is `false`, and
+- `is_constructible_v<T&, const U&>` is `true`.
+*Effects:* Equivalent to:
+``` cpp
+if (rhs.has_value()) convert-ref-init-val(*rhs);
+```
+*Remarks:* This constructor is defined as deleted if
+``` cpp
+reference_constructs_from_temporary_v<T&, const U&>
+```
+is `true`.
+``` cpp
+template<class U>
+  constexpr explicit(!is_convertible_v<U, T&>)
+  optional(optional<U>&& rhs) noexcept(is_nothrow_constructible_v<T&, U>);
+```
+*Constraints:*
+- `is_same_v<remove_cv_t<T>, optional<U>>` is `false`,
+- `is_same_v<T&, U>` is `false`, and
+- `is_constructible_v<T&, U>` is `true`.
+*Effects:* Equivalent to:
+``` cpp
+if (rhs.has_value()) convert-ref-init-val(*std::move(rhs));
+```
+*Remarks:* This constructor is defined as deleted if
+``` cpp
+reference_constructs_from_temporary_v<T&, U>
+```
+is `true`.
+``` cpp
+template<class U>
+  constexpr explicit(!is_convertible_v<const U, T&>)
+  optional(const optional<U>&& rhs) noexcept(is_nothrow_constructible_v<T&, const U>);
+```
+*Constraints:*
+- `is_same_v<remove_cv_t<T>, optional<U>>` is `false`,
+- `is_same_v<T&, U>` is `false`, and
+- `is_constructible_v<T&, const U>` is `true`.
+*Effects:* Equivalent to:
+``` cpp
+if (rhs.has_value()) convert-ref-init-val(*std::move(rhs));
+```
+*Remarks:* This constructor is defined as deleted if
+``` cpp
+reference_constructs_from_temporary_v<T&, const U>
+```
+is `true`.
+#### Assignment <a id="optional.ref.assign">[[optional.ref.assign]]</a>
+``` cpp
+constexpr optional& operator=(nullopt_t) noexcept;
+```
+*Effects:* Assigns `nullptr` to *val*.
+*Ensures:* `*this` does not contain a value.
+*Returns:* `*this`.
+``` cpp
+template<class U>
+  constexpr T& emplace(U&& u) noexcept(is_nothrow_constructible_v<T&, U>);
+```
+*Constraints:*
+- `is_constructible_v<T&, U>` is `true`, and
+- `reference_constructs_from_temporary_v<T&, U>` is `false`.
+*Effects:* Equivalent to:
+*`convert-ref-init-val`*`(std::forward<U>(u))`.
+*Returns:* `*`*`val`*.
+#### Swap <a id="optional.ref.swap">[[optional.ref.swap]]</a>
+``` cpp
+constexpr void swap(optional& rhs) noexcept;
+```
+*Effects:* Equivalent to: `swap(`*`val`*`, rhs.`*`val`*`)`.
+#### Iterator support <a id="optional.ref.iterators">[[optional.ref.iterators]]</a>
+``` cpp
+using iterator = implementation-defined;
+```
+This type models `contiguous_iterator` [[iterator.concept.contiguous]],
+meets the *Cpp17RandomAccessIterator*
+requirements [[random.access.iterators]], and meets the requirements for
+constexpr iterators [[iterator.requirements.general]], with value type
+`remove_cv_t<T>`. The reference type is `T&` for `iterator`.
+All requirements on container iterators [[container.reqmts]] apply to
+`optional::iterator`.
+``` cpp
+constexpr iterator begin() const noexcept;
+```
+*Returns:* If `has_value()` is `true`, an iterator referring to
+`*`*`val`*. Otherwise, a past-the-end iterator value.
+``` cpp
+constexpr iterator end() const noexcept;
+```
+*Returns:* `begin() + has_value()`.
+#### Observers <a id="optional.ref.observe">[[optional.ref.observe]]</a>
+``` cpp
+constexpr T* operator->() const noexcept;
+```
+`has_value()` is `true`.
+*Returns:* *val*.
+``` cpp
+constexpr T& operator*() const noexcept;
+```
+`has_value()` is `true`.
+*Returns:* `*`*`val`*.
+``` cpp
+constexpr explicit operator bool() const noexcept;
+```
+*Returns:* *`val`*` != nullptr`.
+``` cpp
+constexpr bool has_value() const noexcept;
+```
+*Returns:* *`val`*` != nullptr`.
+``` cpp
+constexpr T& value() const;
+```
+*Effects:* Equivalent to:
+``` cpp
+return has_value() ? *val : throw bad_optional_access();
+```
+``` cpp
+template<class U = remove_cv_t<T>> constexpr remove_cv_t<T> value_or(U&& u) const;
+```
+Let `X` be `remove_cv_t<T>`.
+*Mandates:* `is_constructible_v<X, T&> && is_convertible_v<U, X>` is
+`true`.
+*Effects:* Equivalent to:
+``` cpp
+return has_value() ? *val : static_cast<X>(std::forward<U>(u));
+```
+#### Monadic operations <a id="optional.ref.monadic">[[optional.ref.monadic]]</a>
+``` cpp
+template<class F> constexpr auto and_then(F&& f) const;
+```
+Let `U` be `invoke_result_t<F, T&>`.
+*Mandates:* `remove_cvref_t<U>` is a specialization of `optional`.
+*Effects:* Equivalent to:
+``` cpp
+if (has_value()) {
+  return invoke(std::forward<F>(f), *val);
+} else {
+  return remove_cvref_t<U>();
+}
+```
+``` cpp
+template<class F>
+  constexpr optional<remove_cv_t<invoke_result_t<F, T&>>> transform(F&& f) const;
+```
+Let `U` be `remove_cv_t<invoke_result_t<F, T&>>`.
+*Mandates:* The declaration
+``` cpp
+U u(invoke(std::forward<F>(f), *val));
+```
+is well-formed for some invented variable `u`.
+[*Note 1*: There is no requirement that `U` is
+movable [[dcl.init.general]]. — *end note*]
+*Returns:* If `*this` contains a value, an `optional<U>` object whose
+contained value is direct-non-list-initialized with
+`invoke(std::forward<F>(f), *`*`val`*`)`; otherwise, `optional<U>()`.
+``` cpp
+template<class F> constexpr optional or_else(F&& f) const;
+```
+*Constraints:* `F` models `invocable`.
+*Mandates:* `is_same_v<remove_cvref_t<invoke_result_t<F>>, optional>` is
+`true`.
+*Effects:* Equivalent to:
+``` cpp
+if (has_value()) {
+  return *val;
+} else {
+  return std::forward<F>(f)();
+}
+```
+#### Modifiers <a id="optional.ref.mod">[[optional.ref.mod]]</a>
+``` cpp
+constexpr void reset() noexcept;
+```
+*Effects:* Assigns `nullptr` to *val*.
+*Ensures:* `*this` does not contain a value.
+#### Exposition only helper functions <a id="optional.ref.expos">[[optional.ref.expos]]</a>
+``` cpp
+template<class U>
+  constexpr void convert-ref-init-val(U&& u);  // exposition only
+```
+*Effects:* Creates a variable `r` as if by `T& r(std::forward<U>(u));`
+and then initializes *val* with `addressof(r)`.
 ### No-value state indicator <a id="optional.nullopt">[[optional.nullopt]]</a>
 ``` cpp
 struct nullopt_t{see below};
 inline constexpr nullopt_t nullopt(unspecified);
 ``` cpp
 namespace std {
   class bad_optional_access : public exception {
   public:
     // see [exception] for the specification of the special member functions
+ constexpr const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_optional_access` defines the type of objects thrown as
 exceptions to report the situation where an attempt is made to access
 the value of an optional object that does not contain a value.
 ``` cpp
+constexpr const char* what() const noexcept override;
 ```
+*Returns:* An *implementation-defined* NTBS, which during constant
+evaluation is encoded with the ordinary literal encoding [[lex.ccon]].
 ### Relational operators <a id="optional.relops">[[optional.relops]]</a>
 ``` cpp
 template<class T, class U> constexpr bool operator==(const optional<T>& x, const optional<U>& y);
 ```
+*Constraints:* The expression `*x == *y` is well-formed and its result
+is convertible to `bool`.
 [*Note 1*: `T` need not be *Cpp17EqualityComparable*. — *end note*]
 *Returns:* If `x.has_value() != y.has_value()`, `false`; otherwise if
 `x.has_value() == false`, `true`; otherwise `*x == *y`.
 ``` cpp
 template<class T, class U> constexpr bool operator!=(const optional<T>& x, const optional<U>& y);
 ```
+*Constraints:* The expression `*x != *y` is well-formed and its result
+is convertible to `bool`.
 *Returns:* If `x.has_value() != y.has_value()`, `true`; otherwise, if
 `x.has_value() == false`, `false`; otherwise `*x != *y`.
 *Remarks:* Specializations of this function template for which
 ``` cpp
 template<class T, class U> constexpr bool operator<(const optional<T>& x, const optional<U>& y);
 ```
+*Constraints:* `*x < *y` is well-formed and its result is convertible to
 `bool`.
 *Returns:* If `!y`, `false`; otherwise, if `!x`, `true`; otherwise
 `*x < *y`.
 ``` cpp
 template<class T, class U> constexpr bool operator>(const optional<T>& x, const optional<U>& y);
 ```
+*Constraints:* The expression `*x > *y` is well-formed and its result is
 convertible to `bool`.
 *Returns:* If `!x`, `false`; otherwise, if `!y`, `true`; otherwise
 `*x > *y`.
 ``` cpp
 template<class T, class U> constexpr bool operator<=(const optional<T>& x, const optional<U>& y);
 ```
+*Constraints:* The expression `*x <= *y` is well-formed and its result
+is convertible to `bool`.
 *Returns:* If `!x`, `true`; otherwise, if `!y`, `false`; otherwise
 `*x <= *y`.
 *Remarks:* Specializations of this function template for which
 ``` cpp
 template<class T, class U> constexpr bool operator>=(const optional<T>& x, const optional<U>& y);
 ```
+*Constraints:* The expression `*x >= *y` is well-formed and its result
+is convertible to `bool`.
 *Returns:* If `!y`, `true`; otherwise, if `!x`, `false`; otherwise
 `*x >= *y`.
 *Remarks:* Specializations of this function template for which
 ``` cpp
 template<class T, class U> constexpr bool operator==(const optional<T>& x, const U& v);
 ```
+*Constraints:* `U` is not a specialization of `optional`. The expression
+`*x == v` is well-formed and its result is convertible to `bool`.
 [*Note 1*: `T` need not be *Cpp17EqualityComparable*. — *end note*]
 *Effects:* Equivalent to: `return x.has_value() ? *x == v : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator==(const T& v, const optional<U>& x);
 ```
+*Constraints:* `T` is not a specialization of `optional`. The expression
+`v == *x` is well-formed and its result is convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? v == *x : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator!=(const optional<T>& x, const U& v);
 ```
+*Constraints:* `U` is not a specialization of `optional`. The expression
+`*x != v` is well-formed and its result is convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? *x != v : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator!=(const T& v, const optional<U>& x);
 ```
+*Constraints:* `T` is not a specialization of `optional`. The expression
+`v != *x` is well-formed and its result is convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? v != *x : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<(const optional<T>& x, const U& v);
 ```
+*Constraints:* `U` is not a specialization of `optional`. The expression
+`*x < v` is well-formed and its result is convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? *x < v : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<(const T& v, const optional<U>& x);
 ```
+*Constraints:* `T` is not a specialization of `optional`. The expression
+`v < *x` is well-formed and its result is convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? v < *x : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>(const optional<T>& x, const U& v);
 ```
+*Constraints:* `U` is not a specialization of `optional`. The expression
+`*x > v` is well-formed and its result is convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? *x > v : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>(const T& v, const optional<U>& x);
 ```
+*Constraints:* `T` is not a specialization of `optional`. The expression
+`v > *x` is well-formed and its result is convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? v > *x : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<=(const optional<T>& x, const U& v);
 ```
+*Constraints:* `U` is not a specialization of `optional`. The expression
+`*x <= v` is well-formed and its result is convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? *x <= v : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<=(const T& v, const optional<U>& x);
 ```
+*Constraints:* `T` is not a specialization of `optional`. The expression
+`v <= *x` is well-formed and its result is convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? v <= *x : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>=(const optional<T>& x, const U& v);
 ```
+*Constraints:* `U` is not a specialization of `optional`. The expression
+`*x >= v` is well-formed and its result is convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? *x >= v : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>=(const T& v, const optional<U>& x);
 ```
+*Constraints:* `T` is not a specialization of `optional`. The expression
+`v >= *x` is well-formed and its result is convertible to `bool`.
 *Effects:* Equivalent to: `return x.has_value() ? v >= *x : true;`
 ``` cpp
 template<class T, class U>
 ``` cpp
 template<class T>
   constexpr void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y)));
 ```
+*Constraints:*
+``` cpp
+is_reference_v<T> || (is_move_constructible_v<T> && is_swappable_v<T>)
+```
+is `true`.
 *Effects:* Calls `x.swap(y)`.
 ``` cpp
 template<class T> constexpr optional<decay_t<T>> make_optional(T&& v);
 ```
+*Constraints:* The call to `make_optional` does not use an explicit
+*template-argument-list* that begins with a type *template-argument*.
 *Returns:* `optional<decay_t<T>>(std::forward<T>(v))`.
 ``` cpp
 template<class T, class...Args>
   constexpr optional<T> make_optional(Args&&... args);
 unspecified value. The member functions are not guaranteed to be
 `noexcept`.
 ## Variants <a id="variant">[[variant]]</a>
+### General <a id="variant.general">[[variant.general]]</a>
 A variant object holds and manages the lifetime of a value. If the
 `variant` holds a value, that value’s type has to be one of the template
 argument types given to `variant`. These template arguments are called
 alternatives.
+In [[variant]], *`GET`* denotes a set of exposition-only function
+templates [[variant.get]].
 ### Header `<variant>` synopsis <a id="variant.syn">[[variant.syn]]</a>
 ``` cpp
+// mostly freestanding
 #include <compare>              // see [compare.syn]
 namespace std {
   // [variant.variant], class template variant
   template<class... Types>
     struct variant_size<variant<Types...>>;
   template<size_t I, class T> struct variant_alternative;       // not defined
   template<size_t I, class T> struct variant_alternative<I, const T>;
   template<size_t I, class T>
+    using variant_alternative_t = variant_alternative<I, T>::type;
   template<size_t I, class... Types>
     struct variant_alternative<I, variant<Types...>>;
   inline constexpr size_t variant_npos = -1;
   // [variant.get], value access
   template<class T, class... Types>
     constexpr bool holds_alternative(const variant<Types...>&) noexcept;
   template<size_t I, class... Types>
+    constexpr variant_alternative_t<I, variant<Types...>>&
+      get(variant<Types...>&);                                          // freestanding-deleted
   template<size_t I, class... Types>
+    constexpr variant_alternative_t<I, variant<Types...>>&&
+      get(variant<Types...>&&);                                         // freestanding-deleted
   template<size_t I, class... Types>
+    constexpr const variant_alternative_t<I, variant<Types...>>&
+      get(const variant<Types...>&);                                    // freestanding-deleted
   template<size_t I, class... Types>
+    constexpr const variant_alternative_t<I, variant<Types...>>&&
+      get(const variant<Types...>&&);                                   // freestanding-deleted
   template<class T, class... Types>
+    constexpr T& get(variant<Types...>&);                               // freestanding-deleted
   template<class T, class... Types>
+    constexpr T&& get(variant<Types...>&&);                             // freestanding-deleted
   template<class T, class... Types>
+    constexpr const T& get(const variant<Types...>&);                   // freestanding-deleted
   template<class T, class... Types>
+    constexpr const T&& get(const variant<Types...>&&);                 // freestanding-deleted
   template<size_t I, class... Types>
     constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
       get_if(variant<Types...>*) noexcept;
   template<size_t I, class... Types>
     constexpr bool valueless_by_exception() const noexcept;
     constexpr size_t index() const noexcept;
     // [variant.swap], swap
     constexpr void swap(variant&) noexcept(see below);
+    // [variant.visit], visitation
+    template<class Self, class Visitor>
+      constexpr decltype(auto) visit(this Self&&, Visitor&&);
+    template<class R, class Self, class Visitor>
+      constexpr R visit(this Self&&, Visitor&&);
   };
 }
 ```
 Any instance of `variant` at any given time either holds a value of one
 of its alternative types or holds no value. When an instance of
 `variant` holds a value of alternative type `T`, it means that a value
 of type `T`, referred to as the `variant` object’s *contained value*, is
+nested within [[intro.object]] the `variant` object.
 All types in `Types` shall meet the *Cpp17Destructible* requirements (
 [[cpp17.destructible]]).
 A program that instantiates the definition of `variant` with no template
 arguments is ill-formed.
+If a program declares an explicit or partial specialization of
+`variant`, the program is ill-formed, no diagnostic required.
 #### Constructors <a id="variant.ctor">[[variant.ctor]]</a>
 In the descriptions that follow, let i be in the range \[`0`,
 `sizeof...(Types)`), and `Tᵢ` be the iᵗʰ type in `Types`.
 constexpr variant(const variant& w);
 ```
 *Effects:* If `w` holds a value, initializes the `variant` to hold the
 same alternative as `w` and direct-initializes the contained value with
+*`GET`*`<j>(w)`, where `j` is `w.index()`. Otherwise, initializes the
 `variant` to not hold a value.
 *Throws:* Any exception thrown by direct-initializing any `Tᵢ` for all
 i.
 *Constraints:* `is_move_constructible_v<``Tᵢ``>` is `true` for all i.
 *Effects:* If `w` holds a value, initializes the `variant` to hold the
 same alternative as `w` and direct-initializes the contained value with
+*`GET`*`<j>(std::move(w))`, where `j` is `w.index()`. Otherwise,
+initializes the `variant` to not hold a value.
 *Throws:* Any exception thrown by move-constructing any `Tᵢ` for all i.
 *Remarks:* The exception specification is equivalent to the logical of
 `is_nothrow_move_constructible_v<``Tᵢ``>` for all i. If
   value contained in `*this` and sets `*this` to not hold a value.
 - Otherwise, if `index() == `j, assigns the value contained in `rhs` to
   the value contained in `*this`.
 - Otherwise, if either `is_nothrow_copy_constructible_v<``Tⱼ``>` is
   `true` or `is_nothrow_move_constructible_v<``Tⱼ``>` is `false`,
+  equivalent to `emplace<`j`>(`*`GET`*`<`j`>(rhs))`.
 - Otherwise, equivalent to `operator=(variant(rhs))`.
 *Ensures:* `index() == rhs.index()`.
 *Returns:* `*this`.
 *Effects:*
 - If neither `*this` nor `rhs` holds a value, there is no effect.
 - Otherwise, if `*this` holds a value but `rhs` does not, destroys the
   value contained in `*this` and sets `*this` to not hold a value.
+- Otherwise, if `index() == `j, assigns *`GET`*`<`j`>(std::move(rhs))`
+ to the value contained in `*this`.
+- Otherwise, equivalent to
+  `emplace<`j`>(`*`GET`*`<`j`>(std::move(rhs)))`.
 *Returns:* `*this`.
 *Remarks:* If `is_trivially_move_constructible_v<``Tᵢ``> &&`
 `is_trivially_move_assignable_v<``Tᵢ``> &&`
 *Effects:*
 - If `valueless_by_exception() && rhs.valueless_by_exception()` no
   effect.
 - Otherwise, if `index() == rhs.index()`, calls
+  `swap(`*`GET`*`<`i`>(*this), `*`GET`*`<`i`>(rhs))` where i is
+  `index()`.
 - Otherwise, exchanges values of `rhs` and `*this`.
 *Throws:* If `index() == rhs.index()`, any exception thrown by
+`swap(`*`GET`*`<`i`>(*this), `*`GET`*`<`i`>(rhs))` with i being
+`index()`. Otherwise, any exception thrown by the move constructor of
+`Tᵢ` or `Tⱼ` with i being `index()` and j being `rhs.index()`.
 *Remarks:* If an exception is thrown during the call to function
+`swap(`*`GET`*`<`i`>(*this), `*`GET`*`<`i`>(rhs))`, the states of the
+contained values of `*this` and of `rhs` are determined by the exception
+safety guarantee of `swap` for lvalues of `Tᵢ` with i being `index()`.
+If an exception is thrown during the exchange of the values of `*this`
+and `rhs`, the states of the values of `*this` and of `rhs` are
+determined by the exception safety guarantee of `variant`’s move
+constructor. The exception specification is equivalent to the logical of
 `is_nothrow_move_constructible_v<``Tᵢ``> && is_nothrow_swappable_v<``Tᵢ``>`
 for all i.
 ### `variant` helper classes <a id="variant.helper">[[variant.helper]]</a>
 ```
 Let `VA` denote `variant_alternative<I, T>` of the cv-unqualified type
 `T`. Then each specialization of the template meets the
 *Cpp17TransformationTrait* requirements [[meta.rqmts]] with a member
+typedef `type` that names the type `const VA::type`.
 ``` cpp
 variant_alternative<I, variant<Types...>>::type
 ```
 *Mandates:* `I` < `sizeof...(Types)`.
+*Result:* The type `T_I`.
 ### Value access <a id="variant.get">[[variant.get]]</a>
 ``` cpp
 template<class T, class... Types>
 *Mandates:* The type `T` occurs exactly once in `Types`.
 *Returns:* `true` if `index()` is equal to the zero-based index of `T`
 in `Types`.
+``` cpp
+template<size_t I, class... Types>
+  constexpr variant_alternative_t<I, variant<Types...>>&
+    GET(variant<Types...>& v);                                  // exposition only
+template<size_t I, class... Types>
+  constexpr variant_alternative_t<I, variant<Types...>>&&
+    GET(variant<Types...>&& v);                                 // exposition only
+template<size_t I, class... Types>
+  constexpr const variant_alternative_t<I, variant<Types...>>&
+    GET(const variant<Types...>& v);                            // exposition only
+template<size_t I, class... Types>
+  constexpr const variant_alternative_t<I, variant<Types...>>&&
+    GET(const variant<Types...>&& v);                           // exposition only
+```
+*Mandates:* `I` < `sizeof...(Types)`.
+*Preconditions:* `v.index()` is `I`.
+*Returns:* A reference to the object stored in the `variant`.
 ``` cpp
 template<size_t I, class... Types>
   constexpr variant_alternative_t<I, variant<Types...>>& get(variant<Types...>& v);
 template<size_t I, class... Types>
   constexpr variant_alternative_t<I, variant<Types...>>&& get(variant<Types...>&& v);
 ``` cpp
 template<class... Types>
   constexpr bool operator==(const variant<Types...>& v, const variant<Types...>& w);
 ```
+*Constraints:* *`GET`*`<`i`>(v) == `*`GET`*`<`i`>(w)` is a valid
+expression that is convertible to `bool`, for all i.
 *Returns:* If `v.index() != w.index()`, `false`; otherwise if
 `v.valueless_by_exception()`, `true`; otherwise
+*`GET`*`<`i`>(v) == `*`GET`*`<`i`>(w)` with i being `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator!=(const variant<Types...>& v, const variant<Types...>& w);
 ```
+*Constraints:* *`GET`*`<`i`>(v) != `*`GET`*`<`i`>(w)` is a valid
+expression that is convertible to `bool`, for all i.
 *Returns:* If `v.index() != w.index()`, `true`; otherwise if
 `v.valueless_by_exception()`, `false`; otherwise
+*`GET`*`<`i`>(v) != `*`GET`*`<`i`>(w)` with i being `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator<(const variant<Types...>& v, const variant<Types...>& w);
 ```
+*Constraints:* *`GET`*`<`i`>(v) < `*`GET`*`<`i`>(w)` is a valid
+expression that is convertible to `bool`, for all i.
 *Returns:* If `w.valueless_by_exception()`, `false`; otherwise if
 `v.valueless_by_exception()`, `true`; otherwise, if
 `v.index() < w.index()`, `true`; otherwise if `v.index() > w.index()`,
+`false`; otherwise *`GET`*`<`i`>(v) < `*`GET`*`<`i`>(w)` with i being
+`v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator>(const variant<Types...>& v, const variant<Types...>& w);
 ```
+*Constraints:* *`GET`*`<`i`>(v) > `*`GET`*`<`i`>(w)` is a valid
+expression that is convertible to `bool`, for all i.
 *Returns:* If `v.valueless_by_exception()`, `false`; otherwise if
 `w.valueless_by_exception()`, `true`; otherwise, if
 `v.index() > w.index()`, `true`; otherwise if `v.index() < w.index()`,
+`false`; otherwise *`GET`*`<`i`>(v) > `*`GET`*`<`i`>(w)` with i being
+`v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator<=(const variant<Types...>& v, const variant<Types...>& w);
 ```
+*Constraints:* *`GET`*`<`i`>(v) <= `*`GET`*`<`i`>(w)` is a valid
+expression that is convertible to `bool`, for all i.
 *Returns:* If `v.valueless_by_exception()`, `true`; otherwise if
 `w.valueless_by_exception()`, `false`; otherwise, if
 `v.index() < w.index()`, `true`; otherwise if `v.index() > w.index()`,
+`false`; otherwise *`GET`*`<`i`>(v) <= `*`GET`*`<`i`>(w)` with i being
 `v.index()`.
 ``` cpp
 template<class... Types>
   constexpr bool operator>=(const variant<Types...>& v, const variant<Types...>& w);
 ```
+*Constraints:* *`GET`*`<`i`>(v) >= `*`GET`*`<`i`>(w)` is a valid
+expression that is convertible to `bool`, for all i.
 *Returns:* If `w.valueless_by_exception()`, `true`; otherwise if
 `v.valueless_by_exception()`, `false`; otherwise, if
 `v.index() > w.index()`, `true`; otherwise if `v.index() < w.index()`,
+`false`; otherwise *`GET`*`<`i`>(v) >= `*`GET`*`<`i`>(w)` with i being
 `v.index()`.
 ``` cpp
 template<class... Types> requires (three_way_comparable<Types> && ...)
   constexpr common_comparison_category_t<compare_three_way_result_t<Types>...>
 if (v.valueless_by_exception() && w.valueless_by_exception())
   return strong_ordering::equal;
 if (v.valueless_by_exception()) return strong_ordering::less;
 if (w.valueless_by_exception()) return strong_ordering::greater;
 if (auto c = v.index() <=> w.index(); c != 0) return c;
+return GET<i>(v) <=> GET<i>(w);
 ```
 with i being `v.index()`.
 ### Visitation <a id="variant.visit">[[variant.visit]]</a>
 Let *as-variant* denote the following exposition-only function
 templates:
 ``` cpp
 template<class... Ts>
+ constexpr auto&& as-variant(variant<Ts...>& var) { return var; }
 template<class... Ts>
+ constexpr auto&& as-variant(const variant<Ts...>& var) { return var; }
 template<class... Ts>
+ constexpr auto&& as-variant(variant<Ts...>&& var) { return std::move(var); }
 template<class... Ts>
+ constexpr auto&& as-variant(const variant<Ts...>&& var) { return std::move(var); }
 ```
 Let n be `sizeof...(Variants)`. For each 0 ≤ i < n, let `Vᵢ` denote the
 type
 `decltype(`*`as-variant`*`(``std::forward<``Variantsᵢ``>(``varsᵢ``)``))`.
 Let m be a pack of n values of type `size_t`. Such a pack is valid if
 0 ≤ mᵢ < `variant_size_v<remove_reference_t<Vᵢ``>>` for all 0 ≤ i < n.
 For each valid pack m, let e(m) denote the expression:
 ``` cpp
+INVOKE(std::forward<Visitor>(vis), GET<m>(std::forward<V>(vars))...)  // see [func.require]
 ```
 for the first form and
 ``` cpp
+INVOKE<R>(std::forward<Visitor>(vis), GET<m>(std::forward<V>(vars))...)  // see [func.require]
 ```
 for the second form.
 *Mandates:* For each valid pack m, e(m) is a valid expression. All such
 *Complexity:* For n ≤ 1, the invocation of the callable object is
 implemented in constant time, i.e., for n = 1, it does not depend on the
 number of alternative types of `V₀`. For n > 1, the invocation of the
 callable object has no complexity requirements.
+``` cpp
+template<class Self, class Visitor>
+  constexpr decltype(auto) visit(this Self&& self, Visitor&& vis);
+```
+Let `V` be
+*`OVERRIDE_REF`*`(Self&&, `*`COPY_CONST`*`(remove_reference_t<Self>, variant))`
+[[forward]].
+*Constraints:* The call to `visit` does not use an explicit
+*template-argument-list* that begins with a type *template-argument*.
+*Effects:* Equivalent to:
+`return std::visit(std::forward<Visitor>(vis), (V)self);`
+``` cpp
+template<class R, class Self, class Visitor>
+  constexpr R visit(this Self&& self, Visitor&& vis);
+```
+Let `V` be
+*`OVERRIDE_REF`*`(Self&&, `*`COPY_CONST`*`(remove_reference_t<Self>, variant))`
+[[forward]].
+*Effects:* Equivalent to:
+`return std::visit<R>(std::forward<Visitor>(vis), (V)self);`
 ### Class `monostate` <a id="variant.monostate">[[variant.monostate]]</a>
 ``` cpp
 struct monostate{};
 ```
 ``` cpp
 namespace std {
   class bad_variant_access : public exception {
   public:
     // see [exception] for the specification of the special member functions
+ constexpr const char* what() const noexcept override;
   };
 }
 ```
 Objects of type `bad_variant_access` are thrown to report invalid
 accesses to the value of a `variant` object.
 ``` cpp
+constexpr const char* what() const noexcept override;
 ```
+*Returns:* An *implementation-defined* NTBS, which during constant
+evaluation is encoded with the ordinary literal encoding [[lex.ccon]].
 ### Hash support <a id="variant.hash">[[variant.hash]]</a>
 ``` cpp
 template<class... Types> struct hash<variant<Types...>>;
   const T* any_cast(const any* operand) noexcept;
 template<class T>
   T* any_cast(any* operand) noexcept;
 ```
+*Mandates:* `is_void_v<T>` is `false`.
+*Returns:* If `operand != nullptr && operand->type() == typeid(T)` is
+`true`, a pointer to the object contained by `operand`; otherwise,
+`nullptr`.
 [*Example 2*:
 ``` cpp
 bool is_string(const any& operand) {
 — *end example*]
 ## Expected objects <a id="expected">[[expected]]</a>
+### General <a id="expected.general">[[expected.general]]</a>
 Subclause [[expected]] describes the class template `expected` that
 represents expected objects. An `expected<T, E>` object holds an object
+of type `T` or an object of type `E` and manages the lifetime of the
+contained objects.
 ### Header `<expected>` synopsis <a id="expected.syn">[[expected.syn]]</a>
 ``` cpp
+// mostly freestanding
 namespace std {
   // [expected.unexpected], class template unexpected
   template<class E> class unexpected;
   // [expected.bad], class template bad_expected_access
     explicit unexpect_t() = default;
   };
   inline constexpr unexpect_t unexpect{};
   // [expected.expected], class template expected
+  template<class T, class E> class expected;                                // partially freestanding
   // [expected.void], partial specialization of expected for void types
+  template<class T, class E> requires is_void_v<T> class expected<T, E>;    // partially freestanding
 }
 ```
 ### Class template `unexpected` <a id="expected.unexpected">[[expected.unexpected]]</a>
 ``` cpp
 namespace std {
   template<class E>
   class bad_expected_access : public bad_expected_access<void> {
   public:
+ constexpr explicit bad_expected_access(E);
+ constexpr const char* what() const noexcept override;
+ constexpr E& error() & noexcept;
+ constexpr const E& error() const & noexcept;
+ constexpr E&& error() && noexcept;
+ constexpr const E&& error() const && noexcept;
   private:
     E unex;             // exposition only
   };
 }
 thrown as exceptions to report the situation where an attempt is made to
 access the value of an `expected<T, E>` object for which `has_value()`
 is `false`.
 ``` cpp
+constexpr explicit bad_expected_access(E e);
 ```
 *Effects:* Initializes *unex* with `std::move(e)`.
 ``` cpp
+constexpr const E& error() const & noexcept;
+constexpr E& error() & noexcept;
 ```
 *Returns:* *unex*.
 ``` cpp
+constexpr E&& error() && noexcept;
+constexpr const E&& error() const && noexcept;
 ```
 *Returns:* `std::move(`*`unex`*`)`.
 ``` cpp
+constexpr const char* what() const noexcept override;
 ```
+*Returns:* An *implementation-defined* NTBS, which during constant
+evaluation is encoded with the ordinary literal encoding [[lex.ccon]].
 ### Class template specialization `bad_expected_access<void>` <a id="expected.bad.void">[[expected.bad.void]]</a>
 ``` cpp
 namespace std {
   template<>
   class bad_expected_access<void> : public exception {
   protected:
+ constexpr bad_expected_access() noexcept;
+ constexpr bad_expected_access(const bad_expected_access&) noexcept;
+ constexpr bad_expected_access(bad_expected_access&&) noexcept;
+ constexpr bad_expected_access& operator=(const bad_expected_access&) noexcept;
+ constexpr bad_expected_access& operator=(bad_expected_access&&) noexcept;
+ constexpr ~bad_expected_access();
   public:
+ constexpr const char* what() const noexcept override;
   };
 }
 ```
 ``` cpp
+constexpr const char* what() const noexcept override;
 ```
+*Returns:* An *implementation-defined* NTBS, which during constant
+evaluation is encoded with the ordinary literal encoding [[lex.ccon]].
 ### Class template `expected` <a id="expected.expected">[[expected.expected]]</a>
 #### General <a id="expected.object.general">[[expected.object.general]]</a>
     template<class U, class G>
       constexpr explicit(see below) expected(const expected<U, G>&);
     template<class U, class G>
       constexpr explicit(see below) expected(expected<U, G>&&);
+    template<class U = remove_cv_t<T>>
       constexpr explicit(see below) expected(U&& v);
     template<class G>
       constexpr explicit(see below) expected(const unexpected<G>&);
     template<class G>
     constexpr ~expected();
     // [expected.object.assign], assignment
     constexpr expected& operator=(const expected&);
     constexpr expected& operator=(expected&&) noexcept(see below);
+    template<class U = remove_cv_t<T>> constexpr expected& operator=(U&&);
     template<class G>
       constexpr expected& operator=(const unexpected<G>&);
     template<class G>
       constexpr expected& operator=(unexpected<G>&&);
     constexpr T& operator*() & noexcept;
     constexpr const T&& operator*() const && noexcept;
     constexpr T&& operator*() && noexcept;
     constexpr explicit operator bool() const noexcept;
     constexpr bool has_value() const noexcept;
+    constexpr const T& value() const &;                                     // freestanding-deleted
+    constexpr T& value() &;                                                 // freestanding-deleted
+    constexpr const T&& value() const &&;                                   // freestanding-deleted
+    constexpr T&& value() &&;                                               // freestanding-deleted
     constexpr const E& error() const & noexcept;
     constexpr E& error() & noexcept;
     constexpr const E&& error() const && noexcept;
     constexpr E&& error() && noexcept;
+    template<class U = remove_cv_t<T>> constexpr T value_or(U&&) const &;
+    template<class U = remove_cv_t<T>> constexpr T value_or(U&&) &&;
     template<class G = E> constexpr E error_or(G&&) const &;
     template<class G = E> constexpr E error_or(G&&) &&;
     // [expected.object.monadic], monadic operations
     template<class F> constexpr auto and_then(F&& f) &;
   };
 }
 ```
 Any object of type `expected<T, E>` either contains a value of type `T`
+or a value of type `E` nested within [[intro.object]] it. Member
+*`has_val`* indicates whether the `expected<T, E>` object contains an
+object of type `T`.
 A type `T` is a *valid value type for `expected`*, if `remove_cv_t<T>`
 is `void` or a complete non-array object type that is not `in_place_t`,
 `unexpect_t`, or a specialization of `unexpected`. A program which
 instantiates class template `expected<T, E>` with an argument `T` that
 *Remarks:* The expression inside `explicit` is equivalent to
 `!is_convertible_v<UF, T> || !is_convertible_v<GF, E>`.
 ``` cpp
+template<class U = remove_cv_t<T>>
   constexpr explicit(!is_convertible_v<U, T>) expected(U&& v);
 ```
 *Constraints:*
 - `is_same_v<remove_cvref_t<U>, in_place_t>` is `false`; and
+- `is_same_v<remove_cvref_t<U>, expected>` is `false`; and
+- `is_same_v<remove_cvref_t<U>, unexpect_t>` is `false`; and
 - `remove_cvref_t<U>` is not a specialization of `unexpected`; and
 - `is_constructible_v<T, U>` is `true`; and
 - if `T` is cv `bool`, `remove_cvref_t<U>` is not a specialization of
   `expected`.
 `is_trivially_destructible_v<E>` is `true`, then this destructor is a
 trivial destructor.
 #### Assignment <a id="expected.object.assign">[[expected.object.assign]]</a>
+This subclause makes use of the following exposition-only function
+template:
 ``` cpp
 template<class T, class U, class... Args>
 constexpr void reinit-expected(T& newval, U& oldval, Args&&... args) {  // exposition only
   if constexpr (is_nothrow_constructible_v<T, Args...>) {
 is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T> &&
 is_nothrow_move_assignable_v<E> && is_nothrow_move_constructible_v<E>
 ```
 ``` cpp
+template<class U = remove_cv_t<T>>
   constexpr expected& operator=(U&& v);
 ```
 *Constraints:*
 | \topline | `this->has_value()` | `!this->has_value()` |
 | -------- | ------------------- | -------------------- |
+For the case where `rhs.has_value()` is `false` and `this->has_value()`
+is `true`, equivalent to:
 ``` cpp
 if constexpr (is_nothrow_move_constructible_v<E>) {
   E tmp(std::move(rhs.unex));
   destroy_at(addressof(rhs.unex));
 ``` cpp
 constexpr const T* operator->() const noexcept;
 constexpr T* operator->() noexcept;
 ```
+`has_value()` is `true`.
 *Returns:* `addressof(`*`val`*`)`.
 ``` cpp
 constexpr const T& operator*() const & noexcept;
 constexpr T& operator*() & noexcept;
 ```
+`has_value()` is `true`.
 *Returns:* *val*.
 ``` cpp
 constexpr T&& operator*() && noexcept;
 constexpr const T&& operator*() const && noexcept;
 ```
+`has_value()` is `true`.
 *Returns:* `std::move(`*`val`*`)`.
 ``` cpp
 constexpr explicit operator bool() const noexcept;
 ``` cpp
 constexpr const E& error() const & noexcept;
 constexpr E& error() & noexcept;
 ```
+`has_value()` is `false`.
 *Returns:* *unex*.
 ``` cpp
 constexpr E&& error() && noexcept;
 constexpr const E&& error() const && noexcept;
 ```
+`has_value()` is `false`.
 *Returns:* `std::move(`*`unex`*`)`.
 ``` cpp
+template<class U = remove_cv_t<T>> constexpr T value_or(U&& v) const &;
 ```
 *Mandates:* `is_copy_constructible_v<T>` is `true` and
 `is_convertible_v<U, T>` is `true`.
 *Returns:* `has_value() ? **this : static_cast<T>(std::forward<U>(v))`.
 ``` cpp
+template<class U = remove_cv_t<T>> constexpr T value_or(U&& v) &&;
 ```
 *Mandates:* `is_move_constructible_v<T>` is `true` and
 `is_convertible_v<U, T>` is `true`.
 ``` cpp
 template<class F> constexpr auto and_then(F&& f) &;
 template<class F> constexpr auto and_then(F&& f) const &;
 ```
+Let `U` be `remove_cvref_t<invoke_result_t<F, decltype((`*`val`*`))>>`.
 *Constraints:* `is_constructible_v<E, decltype(error())>` is `true`.
 *Mandates:* `U` is a specialization of `expected` and
+`is_same_v<typename U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
+  return invoke(std::forward<F>(f), val);
 else
   return U(unexpect, error());
 ```
 ``` cpp
 template<class F> constexpr auto and_then(F&& f) &&;
 template<class F> constexpr auto and_then(F&& f) const &&;
 ```
 Let `U` be
+`remove_cvref_t<invoke_result_t<F, decltype(std::move(`*`val`*`))>>`.
 *Constraints:* `is_constructible_v<E, decltype(std::move(error()))>` is
 `true`.
 *Mandates:* `U` is a specialization of `expected` and
+`is_same_v<typename U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
+  return invoke(std::forward<F>(f), std::move(val));
 else
   return U(unexpect, std::move(error()));
 ```
 ``` cpp
 template<class F> constexpr auto or_else(F&& f) const &;
 ```
 Let `G` be `remove_cvref_t<invoke_result_t<F, decltype(error())>>`.
+*Constraints:* `is_constructible_v<T, decltype((`*`val`*`))>` is `true`.
 *Mandates:* `G` is a specialization of `expected` and
+`is_same_v<typename G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
+  return G(in_place, val);
 else
   return invoke(std::forward<F>(f), error());
 ```
 ``` cpp
 ```
 Let `G` be
 `remove_cvref_t<invoke_result_t<F, decltype(std::move(error()))>>`.
+*Constraints:* `is_constructible_v<T, decltype(std::move(`*`val`*`))>`
+is `true`.
 *Mandates:* `G` is a specialization of `expected` and
+`is_same_v<typename G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
+  return G(in_place, std::move(val));
 else
   return invoke(std::forward<F>(f), std::move(error()));
 ```
 ``` cpp
 template<class F> constexpr auto transform(F&& f) &;
 template<class F> constexpr auto transform(F&& f) const &;
 ```
+Let `U` be `remove_cv_t<invoke_result_t<F, decltype((`*`val`*`))>>`.
 *Constraints:* `is_constructible_v<E, decltype(error())>` is `true`.
 *Mandates:* `U` is a valid value type for `expected`. If `is_void_v<U>`
 is `false`, the declaration
 ``` cpp
+U u(invoke(std::forward<F>(f), val));
 ```
 is well-formed.
 *Effects:*
 - If `has_value()` is `false`, returns
   `expected<U, E>(unexpect, error())`.
 - Otherwise, if `is_void_v<U>` is `false`, returns an `expected<U, E>`
   object whose *has_val* member is `true` and *val* member is
   direct-non-list-initialized with
+  `invoke(std::forward<F>(f), `*`val`*`)`.
+- Otherwise, evaluates `invoke(std::forward<F>(f), `*`val`*`)` and then
   returns `expected<U, E>()`.
 ``` cpp
 template<class F> constexpr auto transform(F&& f) &&;
 template<class F> constexpr auto transform(F&& f) const &&;
 ```
 Let `U` be
+`remove_cv_t<invoke_result_t<F, decltype(std::move(`*`val`*`))>>`.
 *Constraints:* `is_constructible_v<E, decltype(std::move(error()))>` is
 `true`.
 *Mandates:* `U` is a valid value type for `expected`. If `is_void_v<U>`
 is `false`, the declaration
 ``` cpp
+U u(invoke(std::forward<F>(f), std::move(val)));
 ```
+is well-formed.
 *Effects:*
 - If `has_value()` is `false`, returns
   `expected<U, E>(unexpect, std::move(error()))`.
 - Otherwise, if `is_void_v<U>` is `false`, returns an `expected<U, E>`
   object whose *has_val* member is `true` and *val* member is
   direct-non-list-initialized with
+  `invoke(std::forward<F>(f), std::move(`*`val`*`))`.
+- Otherwise, evaluates
+  `invoke(std::forward<F>(f), std::move(`*`val`*`))` and then returns
+  `expected<U, E>()`.
 ``` cpp
 template<class F> constexpr auto transform_error(F&& f) &;
 template<class F> constexpr auto transform_error(F&& f) const &;
 ```
 Let `G` be `remove_cv_t<invoke_result_t<F, decltype(error())>>`.
+*Constraints:* `is_constructible_v<T, decltype((`*`val`*`))>` is `true`.
 *Mandates:* `G` is a valid template argument for `unexpected`
 [[expected.un.general]] and the declaration
 ``` cpp
 ```
 is well-formed.
 *Returns:* If `has_value()` is `true`,
+`expected<T, G>(in_place, `*`val`*`)`; otherwise, an `expected<T, G>`
 object whose *has_val* member is `false` and *unex* member is
 direct-non-list-initialized with `invoke(std::forward<F>(f), error())`.
 ``` cpp
 template<class F> constexpr auto transform_error(F&& f) &&;
 ```
 Let `G` be
 `remove_cv_t<invoke_result_t<F, decltype(std::move(error()))>>`.
+*Constraints:* `is_constructible_v<T, decltype(std::move(`*`val`*`))>`
+is `true`.
 *Mandates:* `G` is a valid template argument for `unexpected`
 [[expected.un.general]] and the declaration
 ``` cpp
 ```
 is well-formed.
 *Returns:* If `has_value()` is `true`,
+`expected<T, G>(in_place, std::move(`*`val`*`))`; otherwise, an
 `expected<T, G>` object whose *has_val* member is `false` and *unex*
 member is direct-non-list-initialized with
 `invoke(std::forward<F>(f), std::move(error()))`.
 #### Equality operators <a id="expected.object.eq">[[expected.object.eq]]</a>
 ``` cpp
 template<class T2, class E2> requires (!is_void_v<T2>)
   friend constexpr bool operator==(const expected& x, const expected<T2, E2>& y);
 ```
+*Constraints:* The expressions `*x == *y` and `x.error() == y.error()`
+are well-formed and their results are convertible to `bool`.
 *Returns:* If `x.has_value()` does not equal `y.has_value()`, `false`;
 otherwise if `x.has_value()` is `true`, `*x == *y`; otherwise
 `x.error() == y.error()`.
 ``` cpp
 template<class T2> friend constexpr bool operator==(const expected& x, const T2& v);
 ```
+*Constraints:* `T2` is not a specialization of `expected`. The
+expression `*x == v` is well-formed and its result is convertible to
+`bool`.
 [*Note 1*: `T` need not be *Cpp17EqualityComparable*. — *end note*]
 *Returns:* `x.has_value() && static_cast<bool>(*x == v)`.
 ``` cpp
 template<class E2> friend constexpr bool operator==(const expected& x, const unexpected<E2>& e);
 ```
+*Constraints:* The expression `x.error() == e.error()` is well-formed
+and its result is convertible to `bool`.
 *Returns:*
 `!x.has_value() && static_cast<bool>(x.error() == e.error())`.
 ### Partial specialization of `expected` for `void` types <a id="expected.void">[[expected.void]]</a>
   // [expected.void.obs], observers
   constexpr explicit operator bool() const noexcept;
   constexpr bool has_value() const noexcept;
   constexpr void operator*() const noexcept;
+  constexpr void value() const &;                                           // freestanding-deleted
+  constexpr void value() &&;                                                // freestanding-deleted
   constexpr const E& error() const & noexcept;
   constexpr E& error() & noexcept;
   constexpr const E&& error() const && noexcept;
   constexpr E&& error() && noexcept;
   template<class G = E> constexpr E error_or(G&&) const &;
   };
 };
 ```
 Any object of type `expected<T, E>` either represents a value of type
+`T`, or contains a value of type `E` nested within [[intro.object]] it.
+Member *`has_val`* indicates whether the `expected<T, E>` object
+represents a value of type `T`.
 A program that instantiates the definition of the template
 `expected<T, E>` with a type for the `E` parameter that is not a valid
 template argument for `unexpected` is ill-formed.
 ``` cpp
 constexpr expected& operator=(expected&& rhs) noexcept(see below);
 ```
+*Constraints:* `is_move_constructible_v<E>` is `true` and
+`is_move_assignable_v<E>` is `true`.
 *Effects:*
 - If `this->has_value() && rhs.has_value()` is `true`, no effects.
 - Otherwise, if `this->has_value()` is `true`, equivalent to:
   ``` cpp
 *Returns:* `*this`.
 *Remarks:* The exception specification is equivalent to
 `is_nothrow_move_constructible_v<E> && is_nothrow_move_assignable_v<E>`.
 ``` cpp
 template<class G>
   constexpr expected& operator=(const unexpected<G>& e);
 template<class G>
   constexpr expected& operator=(unexpected<G>&& e);
 | \topline | `this->has_value()` | `!this->has_value()` |
 | -------- | ------------------- | -------------------- |
+For the case where `rhs.has_value()` is `false` and `this->has_value()`
+is `true`, equivalent to:
 ``` cpp
 construct_at(addressof(unex), std::move(rhs.unex));
 destroy_at(addressof(rhs.unex));
 has_val = false;
 ``` cpp
 constexpr void operator*() const noexcept;
 ```
+`has_value()` is `true`.
 ``` cpp
 constexpr void value() const &;
 ```
+*Mandates:* `is_copy_constructible_v<E>` is `true`.
 *Throws:* `bad_expected_access(error())` if `has_value()` is `false`.
 ``` cpp
 constexpr void value() &&;
 ```
+*Mandates:* `is_copy_constructible_v<E>` is `true` and
+`is_move_constructible_v<E>` is `true`.
 *Throws:* `bad_expected_access(std::move(error()))` if `has_value()` is
 `false`.
 ``` cpp
 constexpr const E& error() const & noexcept;
 constexpr E& error() & noexcept;
 ```
+`has_value()` is `false`.
 *Returns:* *unex*.
 ``` cpp
 constexpr E&& error() && noexcept;
 constexpr const E&& error() const && noexcept;
 ```
+`has_value()` is `false`.
 *Returns:* `std::move(`*`unex`*`)`.
 ``` cpp
 template<class G = E> constexpr E error_or(G&& e) const &;
 Let `U` be `remove_cvref_t<invoke_result_t<F>>`.
 *Constraints:* `is_constructible_v<E, decltype(error())>>` is `true`.
 *Mandates:* `U` is a specialization of `expected` and
+`is_same_v<typename U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
 *Constraints:* `is_constructible_v<E, decltype(std::move(error()))>` is
 `true`.
 *Mandates:* `U` is a specialization of `expected` and
+`is_same_v<typename U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
 ```
 Let `G` be `remove_cvref_t<invoke_result_t<F, decltype(error())>>`.
 *Mandates:* `G` is a specialization of `expected` and
+`is_same_v<typename G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
 Let `G` be
 `remove_cvref_t<invoke_result_t<F, decltype(std::move(error()))>>`.
 *Mandates:* `G` is a specialization of `expected` and
+`is_same_v<typename G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
 ``` cpp
 template<class T2, class E2> requires is_void_v<T2>
   friend constexpr bool operator==(const expected& x, const expected<T2, E2>& y);
 ```
+*Constraints:* The expression `x.error() == y.error()` is well-formed
+and its result is convertible to `bool`.
 *Returns:* If `x.has_value()` does not equal `y.has_value()`, `false`;
 otherwise `x.has_value() || static_cast<bool>(x.error() == y.error())`.
 ``` cpp
 template<class E2>
   friend constexpr bool operator==(const expected& x, const unexpected<E2>& e);
 ```
+*Constraints:* The expression `x.error() == e.error()` is well-formed
+and its result is convertible to `bool`.
 *Returns:*
 `!x.has_value() && static_cast<bool>(x.error() == e.error())`.
 ## Bitsets <a id="bitset">[[bitset]]</a>
 namespace std {
   template<size_t N> class bitset {
   public:
     // bit reference
     class reference {
     public:
       constexpr reference(const reference&) = default;
       constexpr ~reference();
       constexpr reference& operator=(bool x) noexcept;              // for b[i] = x;
       constexpr reference& operator=(const reference&) noexcept;    // for b[i] = b[j];
         typename basic_string<charT, traits, Allocator>::size_type pos = 0,
         typename basic_string<charT, traits, Allocator>::size_type n
           = basic_string<charT, traits, Allocator>::npos,
         charT zero = charT('0'),
         charT one = charT('1'));
+    template<class charT, class traits>
+      constexpr explicit bitset(
+        basic_string_view<charT, traits> str,
+        typename basic_string_view<charT, traits>::size_type pos = 0,
+        typename basic_string_view<charT, traits>::size_type n
+          = basic_string_view<charT, traits>::npos,
+        charT zero = charT('0'),
+        charT one = charT('1'));
     template<class charT>
       constexpr explicit bitset(
         const charT* str,
+        typename basic_string_view<charT>::size_type n = basic_string_view<charT>::npos,
         charT zero = charT('0'),
         charT one = charT('1'));
     // [bitset.members], bitset operations
     constexpr bitset& operator&=(const bitset& rhs) noexcept;
     typename basic_string<charT, traits, Allocator>::size_type pos = 0,
     typename basic_string<charT, traits, Allocator>::size_type n
       = basic_string<charT, traits, Allocator>::npos,
     charT zero = charT('0'),
     charT one = charT('1'));
+template<class charT, class traits>
+  constexpr explicit bitset(
+    basic_string_view<charT, traits> str,
+    typename basic_string_view<charT, traits>::size_type pos = 0,
+    typename basic_string_view<charT, traits>::size_type n
+      = basic_string_view<charT, traits>::npos,
+    charT zero = charT('0'),
+    charT one = charT('1'));
 ```
 *Effects:* Determines the effective length `rlen` of the initializing
 string as the smaller of `n` and `str.size() - pos`. Initializes the
 first `M` bit positions to values determined from the corresponding
 ``` cpp
 template<class charT>
   constexpr explicit bitset(
     const charT* str,
+    typename basic_string_view<charT>::size_type n = basic_string_view<charT>::npos,
     charT zero = charT('0'),
     charT one = charT('1'));
 ```
 *Effects:* As if by:
 ``` cpp
+bitset(n == basic_string_view<charT>::npos
+          ? basic_string_view<charT>(str)
+          : basic_string_view<charT>(str, n),
        0, n, zero, one)
 ```
 #### Members <a id="bitset.members">[[bitset.members]]</a>
 ``` cpp
 constexpr bool operator[](size_t pos) const;
 ```
+`pos < size()` is `true`.
 *Returns:* `true` if the bit at position `pos` in `*this` has the value
 one, otherwise `false`.
 *Throws:* Nothing.
 ``` cpp
 constexpr bitset::reference operator[](size_t pos);
 ```
+`pos < size()` is `true`.
 *Returns:* An object of type `bitset::reference` such that
 `(*this)[pos] == this->test(pos)`, and such that `(*this)[pos] = val` is
 equivalent to `this->set(pos, val)`.
   // [func.identity], identity
   struct identity;                                                                  // freestanding
   // [func.not.fn], function template not_fn
   template<class F> constexpr unspecified not_fn(F&& f);                            // freestanding
+  template<auto f> constexpr unspecified not_fn() noexcept;                         // freestanding
   // [func.bind.partial], function templates bind_front and bind_back
   template<class F, class... Args>
     constexpr unspecified bind_front(F&&, Args&&...);                               // freestanding
+  template<auto f, class... Args>
+    constexpr unspecified bind_front(Args&&...);                                    // freestanding
   template<class F, class... Args>
     constexpr unspecified bind_back(F&&, Args&&...);                                // freestanding
+  template<auto f, class... Args>
+    constexpr unspecified bind_back(Args&&...);                                     // freestanding
   // [func.bind], bind
   template<class T> struct is_bind_expression;                                      // freestanding
   template<class T>
     constexpr bool is_bind_expression_v =                                           // freestanding
   namespace placeholders {
     // M is the implementation-defined number of placeholders
     see belownc _1;                                                                   // freestanding
     see belownc _2;                                                                   // freestanding
+ ⋮
     see belownc _M;                                                                   // freestanding
   }
   // [func.memfn], member function adaptors
   template<class R, class T>
     constexpr unspecified mem_fn(R T::*) noexcept;                                  // freestanding
   // [func.wrap], polymorphic function wrappers
+  // [func.wrap.badcall], class bad_function_call
   class bad_function_call;
+  // [func.wrap.func], class template function
   template<class> class function;       // not defined
   template<class R, class... ArgTypes> class function<R(ArgTypes...)>;
+  // [func.wrap.func.alg], function specialized algorithms
   template<class R, class... ArgTypes>
     void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
+  // [func.wrap.func.nullptr], function null pointer comparison operator functions
   template<class R, class... ArgTypes>
     bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
+  // [func.wrap.move], move-only wrapper
   template<class... S> class move_only_function;                        // not defined
   template<class R, class... ArgTypes>
     class move_only_function<R(ArgTypes...) cv ref noexcept(noex)>;     // see below
+  // [func.wrap.copy], copyable wrapper
+  template<class... S> class copyable_function;                         // not defined
+  template<class R, class... ArgTypes>
+    class copyable_function<R(ArgTypes...) cv ref noexcept(noex)>;      // see below
+  // [func.wrap.ref], non-owning wrapper
+  template<class... S> class function_ref;                              // freestanding, not defined
+  template<class R, class... ArgTypes>
+    class function_ref<R(ArgTypes...) cv noexcept(noex)>;               // freestanding, see below
   // [func.search], searchers
   template<class ForwardIterator1, class BinaryPredicate = equal_to<>>
     class default_searcher;                                                         // freestanding
   template<class RandomAccessIterator,
     struct greater;                                                                 // freestanding
     struct less;                                                                    // freestanding
     struct greater_equal;                                                           // freestanding
     struct less_equal;                                                              // freestanding
   }
+  template<class Fn, class... Args>
+    concept callable =                                                  // exposition only
+      requires (Fn&& fn, Args&&... args) {
+        std::forward<Fn>(fn)(std::forward<Args>(args)...);
+      };
+  template<class Fn, class... Args>
+    concept nothrow-callable =                                          // exposition only
+      callable<Fn, Args...> &&
+      requires (Fn&& fn, Args&&... args) {
+        { std::forward<Fn>(fn)(std::forward<Args>(args)...) } noexcept;
+      };
+  template<class Fn, class... Args>
+    using call-result-t = decltype(declval<Fn>()(declval<Args>()...));  // exposition only
+  template<const auto& T>
+    using decayed-typeof = decltype(auto(T));                           // exposition only
 }
 ```
 [*Example 1*:
 ### Requirements <a id="func.require">[[func.require]]</a>
 Define `INVOKE(f, t₁, t₂, …, t_N)` as follows:
 - `(t₁.*f)(t₂, …, t_N)` when `f` is a pointer to a member function of a
+  class `T` and `is_same_v<T, remove_cvref_t<decltype(t₁)>> ||`
   `is_base_of_v<T, remove_cvref_t<decltype(t₁)>>` is `true`;
 - `(t₁.get().*f)(t₂, …, t_N)` when `f` is a pointer to a member function
   of a class `T` and `remove_cvref_t<decltype(t₁)>` is a specialization
   of `reference_wrapper`;
 - `((*t₁).*f)(t₂, …, t_N)` when `f` is a pointer to a member function of
   a class `T` and `t₁` does not satisfy the previous two items;
 - `t₁.*f` when N = 1 and `f` is a pointer to data member of a class `T`
+  and `is_same_v<T, remove_cvref_t<decltype(t₁)>> ||`
   `is_base_of_v<T, remove_cvref_t<decltype(t₁)>>` is `true`;
 - `t₁.get().*f` when N = 1 and `f` is a pointer to data member of a
   class `T` and `remove_cvref_t<decltype(t₁)>` is a specialization of
   `reference_wrapper`;
 - `(*t₁).*f` when N = 1 and `f` is a pointer to data member of a class
     // [refwrap.invoke], invocation
     template<class... ArgTypes>
       constexpr invoke_result_t<T&, ArgTypes...> operator()(ArgTypes&&...) const
         noexcept(is_nothrow_invocable_v<T&, ArgTypes...>);
+    // [refwrap.comparisons], comparisons
+    friend constexpr bool operator==(reference_wrapper, reference_wrapper);
+    friend constexpr bool operator==(reference_wrapper, const T&);
+    friend constexpr bool operator==(reference_wrapper, reference_wrapper<const T>);
+    friend constexpr auto operator<=>(reference_wrapper, reference_wrapper);
+    friend constexpr auto operator<=>(reference_wrapper, const T&);
+    friend constexpr auto operator<=>(reference_wrapper, reference_wrapper<const T>);
   };
   template<class T>
     reference_wrapper(T&) -> reference_wrapper<T>;
 }
 [[term.trivially.copyable.type]].
 The template parameter `T` of `reference_wrapper` may be an incomplete
 type.
+[*Note 1*: Using the comparison operators described in
+[[refwrap.comparisons]] with `T` being an incomplete type can lead to an
+ill-formed program with no diagnostic required
+[[temp.point]], [[temp.constr.atomic]]. — *end note*]
 #### Constructors <a id="refwrap.const">[[refwrap.const]]</a>
 ``` cpp
 template<class U>
   constexpr reference_wrapper(U&& u) noexcept(see below);
 ```
 *Mandates:* `T` is a complete type.
 *Returns:* *INVOKE*(get(),
+std::forward\<ArgTypes\>(args)...) [[func.require]].
+#### Comparisons <a id="refwrap.comparisons">[[refwrap.comparisons]]</a>
+``` cpp
+friend constexpr bool operator==(reference_wrapper x, reference_wrapper y);
+```
+*Constraints:* The expression `x.get() == y.get()` is well-formed and
+its result is convertible to `bool`.
+*Returns:* `x.get() == y.get()`.
+``` cpp
+friend constexpr bool operator==(reference_wrapper x, const T& y);
+```
+*Constraints:* The expression `x.get() == y` is well-formed and its
+result is convertible to `bool`.
+*Returns:* `x.get() == y`.
+``` cpp
+friend constexpr bool operator==(reference_wrapper x, reference_wrapper<const T> y);
+```
+*Constraints:* `is_const_v<T>` is `false` and the expression
+`x.get() == y.get()` is well-formed and its result is convertible to
+`bool`.
+*Returns:* `x.get() == y.get()`.
+``` cpp
+friend constexpr auto operator<=>(reference_wrapper x, reference_wrapper y);
+```
+*Constraints:* The expression *`synth-three-way`*`(x.get(), y.get())` is
+well-formed.
+*Returns:* *`synth-three-way`*`(x.get(), y.get())`.
+``` cpp
+friend constexpr auto operator<=>(reference_wrapper x, const T& y);
+```
+*Constraints:* The expression *`synth-three-way`*`(x.get(), y)` is
+well-formed.
+*Returns:* *`synth-three-way`*`(x.get(), y)`.
+``` cpp
+friend constexpr auto operator<=>(reference_wrapper x, reference_wrapper<const T> y);
+```
+*Constraints:* `is_const_v<T>` is `false`. The expression
+*`synth-three-way`*`(x.get(), y.get())` is well-formed.
+*Returns:* *`synth-three-way`*`(x.get(), y.get())`.
 #### Helper functions <a id="refwrap.helpers">[[refwrap.helpers]]</a>
 The template parameter `T` of the following `ref` and `cref` function
 templates may be an incomplete type.
 wrapper [[term.perfect.forwarding.call.wrapper]] `g` with call pattern
 `!invoke(fd, call_args...)`.
 *Throws:* Any exception thrown by the initialization of `fd`.
+``` cpp
+template<auto f> constexpr unspecified not_fn() noexcept;
+```
+In the text that follows:
+- `F` is the type of `f`,
+- `g` is a value of the result of a `not_fn` invocation,
+- `call_args` is an argument pack used in a function call
+  expression [[expr.call]] of `g`.
+*Mandates:* If `is_pointer_v<F> || is_member_pointer_v<F>` is `true`,
+then `f != nullptr` is `true`.
+*Returns:* A perfect forwarding call wrapper [[func.require]] `g` that
+does not have state entities, and has the call pattern
+`!invoke(f, call_args...)`.
 ### Function templates `bind_front` and `bind_back` <a id="func.bind.partial">[[func.bind.partial]]</a>
 ``` cpp
 template<class F, class... Args>
   constexpr unspecified bind_front(F&& f, Args&&... args);
   invocation.
 *Throws:* Any exception thrown by the initialization of the state
 entities of `g` [[func.def]].
+``` cpp
+template<auto f, class... Args>
+  constexpr unspecified bind_front(Args&&... args);
+template<auto f, class... Args>
+  constexpr unspecified bind_back(Args&&... args);
+```
+Within this subclause:
+- `F` is the type of `f`,
+- `g` is a value of the result of a `bind_front` or `bind_back`
+  invocation,
+- `BoundArgs` is a pack that denotes `decay_t<Args>...`,
+- `bound_args` is a pack of bound argument entities of `g` [[func.def]]
+  of types `BoundArgs...`, direct-non-list-initialized with
+  `std::forward<Args>(args)...`, respectively, and
+- `call_args` is an argument pack used in a function call
+  expression [[expr.call]] of `g`.
+*Mandates:*
+- `(is_constructible_v<BoundArgs, Args> && ...)` is `true`, and
+- `(is_move_constructible_v<BoundArgs> && ...)` is `true`, and
+- if `is_pointer_v<F> || is_member_pointer_v<F>` is `true`, then
+  `f != nullptr` is `true`.
+*Preconditions:* For each `Tᵢ` in `BoundArgs`, `Tᵢ` meets the
+*Cpp17MoveConstructible* requirements.
+*Returns:* A perfect forwarding call wrapper [[func.require]] `g` that
+does not have a target object, and has the call pattern:
+- `invoke(f, bound_args..., call_args...)` for a `bind_front`
+  invocation, or
+- `invoke(f, call_args..., bound_args...)` for a `bind_back` invocation.
+*Throws:* Any exception thrown by the initialization of `bound_args`.
 ### Function object binders <a id="func.bind">[[func.bind]]</a>
 #### General <a id="func.bind.general">[[func.bind.general]]</a>
 Subclause [[func.bind]] describes a uniform mechanism for binding
 ``` cpp
 namespace std::placeholders {
   // M is the number of placeholders
   see below _1;
   see below _2;
+             ⋮
   see below _M;
 }
 ```
 The number `M` of placeholders is *implementation-defined*.
 #### General <a id="func.wrap.general">[[func.wrap.general]]</a>
 Subclause [[func.wrap]] describes polymorphic wrapper classes that
 encapsulate arbitrary callable objects.
+Let `t` be an object of a type that is a specialization of `function`,
+`copyable_function`, or `move_only_function`, such that the target
+object `x` of `t` has a type that is a specialization of `function`,
+`copyable_function`, or `move_only_function`. Each argument of the
+invocation of `x` evaluated as part of the invocation of `t` may alias
+an argument in the same position in the invocation of `t` that has the
+same type, even if the corresponding parameter is not of reference type.
+[*Example 1*:
+``` cpp
+move_only_function<void(T)> f{copyable_function<void(T)>{[](T) {}}};
+T t;
+f(t);                               // it is unspecified how many copies of T are made
+```
+— *end example*]
+*Recommended practice:* Implementations should avoid double wrapping
+when constructing polymorphic wrappers from one another.
 #### Class `bad_function_call` <a id="func.wrap.badcall">[[func.wrap.badcall]]</a>
 An exception of type `bad_function_call` is thrown by
 `function::operator()` [[func.wrap.func.inv]] when the function wrapper
 object has no target.
 ##### General <a id="func.wrap.func.general">[[func.wrap.func.general]]</a>
 ``` cpp
 namespace std {
   template<class R, class... ArgTypes>
   class function<R(ArgTypes...)> {
   public:
     using result_type = R;
 The `function` class template provides polymorphic wrappers that
 generalize the notion of a function pointer. Wrappers can store, copy,
 and call arbitrary callable objects [[func.def]], given a call signature
 [[func.def]].
 The `function` class template is a call wrapper [[func.def]] whose call
 signature [[func.def]] is `R(ArgTypes...)`.
 [*Note 1*: The types deduced by the deduction guides for `function`
 might change in future revisions of C++. — *end note*]
 ``` cpp
 function(const function& f);
 ```
 *Ensures:* `!*this` if `!f`; otherwise, the target object of `*this` is
+a copy of the target object of `f`.
 *Throws:* Nothing if `f`’s target is a specialization of
 `reference_wrapper` or a function pointer. Otherwise, may throw
 `bad_alloc` or any exception thrown by the copy constructor of the
 stored callable object.
 Let `FD` be `decay_t<F>`.
 *Constraints:*
 - `is_same_v<remove_cvref_t<F>, function>` is `false`, and
+- `is_invocable_r_v<R, FD&, ArgTypes...>` is `true`.
 *Mandates:*
 - `is_copy_constructible_v<FD>` is `true`, and
 - `is_constructible_v<FD, F>` is `true`.
 ``` cpp
 template<class F> function& operator=(F&& f);
 ```
+*Constraints:* `is_invocable_r_v<R, decay_t<F>&, ArgTypes...>` is
+`true`.
 *Effects:* As if by: `function(std::forward<F>(f)).swap(*this);`
 *Returns:* `*this`.
   void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>& f2) noexcept;
 ```
 *Effects:* As if by: `f1.swap(f2);`
+#### Move-only wrapper <a id="func.wrap.move">[[func.wrap.move]]</a>
 ##### General <a id="func.wrap.move.general">[[func.wrap.move.general]]</a>
 The header provides partial specializations of `move_only_function` for
 each combination of the possible replacements of the placeholders cv,
 ##### Class template `move_only_function` <a id="func.wrap.move.class">[[func.wrap.move.class]]</a>
 ``` cpp
 namespace std {
   template<class R, class... ArgTypes>
   class move_only_function<R(ArgTypes...) cv ref noexcept(noex)> {
   public:
     using result_type = R;
+    // [func.wrap.move.ctor], constructors, assignments, and destructor
     move_only_function() noexcept;
     move_only_function(nullptr_t) noexcept;
     move_only_function(move_only_function&&) noexcept;
     template<class F> move_only_function(F&&);
     template<class T, class... Args>
 [*Note 1*: Such small-object optimization can only be applied to a type
 `T` for which `is_nothrow_move_constructible_v<T>` is
 `true`. — *end note*]
+##### Constructors, assignments, and destructor <a id="func.wrap.move.ctor">[[func.wrap.move.ctor]]</a>
 ``` cpp
 template<class VT>
   static constexpr bool is-callable-from = see below;
 ```
 friend bool operator==(const move_only_function& f, nullptr_t) noexcept;
 ```
 *Returns:* `true` if `f` has no target object, otherwise `false`.
+#### Copyable wrapper <a id="func.wrap.copy">[[func.wrap.copy]]</a>
+##### General <a id="func.wrap.copy.general">[[func.wrap.copy.general]]</a>
+The header provides partial specializations of `copyable_function` for
+each combination of the possible replacements of the placeholders cv,
+*ref*, and *noex* where
+- cv is either const or empty,
+- *ref* is either `&`, `&&`, or empty, and
+- *noex* is either `true` or `false`.
+For each of the possible combinations of the placeholders mentioned
+above, there is a placeholder *inv-quals* defined as follows:
+- If *ref* is empty, let *inv-quals* be cv`&`,
+- otherwise, let *inv-quals* be cv *ref*.
+##### Class template `copyable_function` <a id="func.wrap.copy.class">[[func.wrap.copy.class]]</a>
+``` cpp
+namespace std {
+  template<class R, class... ArgTypes>
+  class copyable_function<R(ArgTypes...) cv ref noexcept(noex)> {
+  public:
+    using result_type = R;
+    // [func.wrap.copy.ctor], constructors, assignments, and destructor
+    copyable_function() noexcept;
+    copyable_function(nullptr_t) noexcept;
+    copyable_function(const copyable_function&);
+    copyable_function(copyable_function&&) noexcept;
+    template<class F> copyable_function(F&&);
+    template<class T, class... Args>
+      explicit copyable_function(in_place_type_t<T>, Args&&...);
+    template<class T, class U, class... Args>
+      explicit copyable_function(in_place_type_t<T>, initializer_list<U>, Args&&...);
+    copyable_function& operator=(const copyable_function&);
+    copyable_function& operator=(copyable_function&&);
+    copyable_function& operator=(nullptr_t) noexcept;
+    template<class F> copyable_function& operator=(F&&);
+    ~copyable_function();
+    // [func.wrap.copy.inv], invocation
+    explicit operator bool() const noexcept;
+    R operator()(ArgTypes...) cv ref noexcept(noex);
+    // [func.wrap.copy.util], utility
+    void swap(copyable_function&) noexcept;
+    friend void swap(copyable_function&, copyable_function&) noexcept;
+    friend bool operator==(const copyable_function&, nullptr_t) noexcept;
+  private:
+    template<class VT>
+      static constexpr bool is-callable-from = see below;       // exposition only
+  };
+}
+```
+The `copyable_function` class template provides polymorphic wrappers
+that generalize the notion of a callable object [[func.def]]. These
+wrappers can store, copy, move, and call arbitrary callable objects,
+given a call signature.
+*Recommended practice:* Implementations should avoid the use of
+dynamically allocated memory for a small contained value.
+[*Note 1*: Such small-object optimization can only be applied to a type
+`T` for which `is_nothrow_move_constructible_v<T>` is
+`true`. — *end note*]
+##### Constructors, assignments, and destructor <a id="func.wrap.copy.ctor">[[func.wrap.copy.ctor]]</a>
+``` cpp
+template<class VT>
+  static constexpr bool is-callable-from = see below;
+```
+If *noex* is `true`, *`is-callable-from`*`<VT>` is equal to:
+``` cpp
+is_nothrow_invocable_r_v<R, VT cv ref, ArgTypes...> &&
+is_nothrow_invocable_r_v<R, VT inv-quals, ArgTypes...>
+```
+Otherwise, *`is-callable-from`*`<VT>` is equal to:
+``` cpp
+is_invocable_r_v<R, VT cv ref, ArgTypes...> &&
+is_invocable_r_v<R, VT inv-quals, ArgTypes...>
+```
+``` cpp
+copyable_function() noexcept;
+copyable_function(nullptr_t) noexcept;
+```
+*Ensures:* `*this` has no target object.
+``` cpp
+copyable_function(const copyable_function& f);
+```
+*Ensures:* `*this` has no target object if `f` had no target object.
+Otherwise, the target object of `*this` is a copy of the target object
+of `f`.
+*Throws:* Any exception thrown by the initialization of the target
+object. May throw `bad_alloc`.
+``` cpp
+copyable_function(copyable_function&& f) noexcept;
+```
+*Ensures:* The target object of `*this` is the target object `f` had
+before construction, and `f` is in a valid state with an unspecified
+value.
+``` cpp
+template<class F> copyable_function(F&& f);
+```
+Let `VT` be `decay_t<F>`.
+*Constraints:*
+- `remove_cvref_t<F>` is not the same type as `copyable_function`, and
+- `remove_cvref_t<F>` is not a specialization of `in_place_type_t`, and
+- *`is-callable-from`*`<VT>` is `true`.
+*Mandates:*
+- `is_constructible_v<VT, F>` is `true`, and
+- `is_copy_constructible_v<VT>` is `true`.
+*Preconditions:* `VT` meets the *Cpp17Destructible* and
+*Cpp17CopyConstructible* requirements.
+*Ensures:* `*this` has no target object if any of the following hold:
+- `f` is a null function pointer value, or
+- `f` is a null member pointer value, or
+- `remove_cvref_t<F>` is a specialization of the `copyable_function`
+  class template, and `f` has no target object.
+Otherwise, `*this` has a target object of type `VT`
+direct-non-list-initialized with `std::forward<F>(f)`.
+*Throws:* Any exception thrown by the initialization of the target
+object. May throw `bad_alloc` unless `VT` is a function pointer or a
+specialization of `reference_wrapper`.
+``` cpp
+template<class T, class... Args>
+  explicit copyable_function(in_place_type_t<T>, Args&&... args);
+```
+Let `VT` be `decay_t<T>`.
+*Constraints:*
+- `is_constructible_v<VT, Args...>` is `true`, and
+- *`is-callable-from`*`<VT>` is `true`.
+*Mandates:*
+- `VT` is the same type as `T`, and
+- `is_copy_constructible_v<VT>` is `true`.
+*Preconditions:* `VT` meets the *Cpp17Destructible* and
+*Cpp17CopyConstructible* requirements.
+*Ensures:* `*this` has a target object of type `VT`
+direct-non-list-initialized with `std::forward<Args>(args)...`.
+*Throws:* Any exception thrown by the initialization of the target
+object. May throw `bad_alloc` unless `VT` is a pointer or a
+specialization of `reference_wrapper`.
+``` cpp
+template<class T, class U, class... Args>
+  explicit copyable_function(in_place_type_t<T>, initializer_list<U> ilist, Args&&... args);
+```
+Let `VT` be `decay_t<T>`.
+*Constraints:*
+- `is_constructible_v<VT, initializer_list<U>&, Args...>` is `true`, and
+- *`is-callable-from`*`<VT>` is `true`.
+*Mandates:*
+- `VT` is the same type as `T`, and
+- `is_copy_constructible_v<VT>` is `true`.
+*Preconditions:* `VT` meets the *Cpp17Destructible* and
+*Cpp17CopyConstructible* requirements.
+*Ensures:* `*this` has a target object of type `VT`
+direct-non-list-initialized with `ilist, std::forward<Args>(args)...`.
+*Throws:* Any exception thrown by the initialization of the target
+object. May throw `bad_alloc` unless `VT` is a pointer or a
+specialization of `reference_wrapper`.
+``` cpp
+copyable_function& operator=(const copyable_function& f);
+```
+*Effects:* Equivalent to: `copyable_function(f).swap(*this);`
+*Returns:* `*this`.
+``` cpp
+copyable_function& operator=(copyable_function&& f);
+```
+*Effects:* Equivalent to: `copyable_function(std::move(f)).swap(*this);`
+*Returns:* `*this`.
+``` cpp
+copyable_function& operator=(nullptr_t) noexcept;
+```
+*Effects:* Destroys the target object of `*this`, if any.
+*Returns:* `*this`.
+``` cpp
+template<class F> copyable_function& operator=(F&& f);
+```
+*Effects:* Equivalent to:
+`copyable_function(std::forward<F>(f)).swap(*this);`
+*Returns:* `*this`.
+``` cpp
+~copyable_function();
+```
+*Effects:* Destroys the target object of `*this`, if any.
+##### Invocation <a id="func.wrap.copy.inv">[[func.wrap.copy.inv]]</a>
+``` cpp
+explicit operator bool() const noexcept;
+```
+*Returns:* `true` if `*this` has a target object, otherwise `false`.
+``` cpp
+R operator()(ArgTypes... args) cv ref noexcept(noex);
+```
+*Preconditions:* `*this` has a target object.
+*Effects:* Equivalent to:
+``` cpp
+return INVOKE<R>(static_cast<F inv-quals>(f), std::forward<ArgTypes>(args)...);
+```
+where `f` is an lvalue designating the target object of `*this` and `F`
+is the type of `f`.
+##### Utility <a id="func.wrap.copy.util">[[func.wrap.copy.util]]</a>
+``` cpp
+void swap(copyable_function& other) noexcept;
+```
+*Effects:* Exchanges the target objects of `*this` and `other`.
+``` cpp
+friend void swap(copyable_function& f1, copyable_function& f2) noexcept;
+```
+*Effects:* Equivalent to `f1.swap(f2)`.
+``` cpp
+friend bool operator==(const copyable_function& f, nullptr_t) noexcept;
+```
+*Returns:* `true` if `f` has no target object, otherwise `false`.
+#### Non-owning wrapper <a id="func.wrap.ref">[[func.wrap.ref]]</a>
+##### General <a id="func.wrap.ref.general">[[func.wrap.ref.general]]</a>
+The header provides partial specializations of `function_ref` for each
+combination of the possible replacements of the placeholders cv and
+*noex* where:
+- cv is either const or empty, and
+- *noex* is either `true` or `false`.
+##### Class template `function_ref` <a id="func.wrap.ref.class">[[func.wrap.ref.class]]</a>
+``` cpp
+namespace std {
+  template<class R, class... ArgTypes>
+  class function_ref<R(ArgTypes...) cv noexcept(noex)> {
+  public:
+    // [func.wrap.ref.ctor], constructors and assignment operators
+    template<class F> function_ref(F*) noexcept;
+    template<class F> constexpr function_ref(F&&) noexcept;
+    template<auto f> constexpr function_ref(nontype_t<f>) noexcept;
+    template<auto f, class U> constexpr function_ref(nontype_t<f>, U&&) noexcept;
+    template<auto f, class T> constexpr function_ref(nontype_t<f>, cv T*) noexcept;
+    constexpr function_ref(const function_ref&) noexcept = default;
+    constexpr function_ref& operator=(const function_ref&) noexcept = default;
+    template<class T> function_ref& operator=(T) = delete;
+    // [func.wrap.ref.inv], invocation
+    R operator()(ArgTypes...) const noexcept(noex);
+  private:
+    template<class... T>
+      static constexpr bool is-invocable-using = see belownc;             // exposition only
+    R (*thunk-ptr)(BoundEntityType, ArgTypes&&...) noexcept(noex);      // exposition only
+    BoundEntityType bound-entity;                                       // exposition only
+  };
+  // [func.wrap.ref.deduct], deduction guides
+  template<class F>
+    function_ref(F*) -> function_ref<F>;
+  template<auto f>
+    function_ref(nontype_t<f>) -> function_ref<see below>;
+  template<auto f, class T>
+    function_ref(nontype_t<f>, T&&) -> function_ref<see below>;
+}
+```
+An object of class `function_ref<R(Args...) cv noexcept(noex)>` stores a
+pointer to function *`thunk-ptr`* and an object *`bound-entity`*. The
+object *`bound-entity`* has an unspecified trivially copyable type
+*`BoundEntityType`*, that models `copyable` and is capable of storing a
+pointer to object value or a pointer to function value. The type of
+*`thunk-ptr`* is `R(*)(BoundEntityType, Args&&...) noexcept(noex)`.
+Each specialization of `function_ref` is a trivially copyable type
+[[term.trivially.copyable.type]] that models `copyable`.
+Within subclause  [[func.wrap.ref]], `call-args` is an argument pack
+with elements such that
+``` cpp
+decltype((call-args))...
+```
+denote `ArgTypes&&...` respectively.
+##### Constructors and assignment operators <a id="func.wrap.ref.ctor">[[func.wrap.ref.ctor]]</a>
+``` cpp
+template<class... T>
+  static constexpr bool is-invocable-using = see below;
+```
+If *noex* is `true`, *`is-invocable-using`*`<T...>` is equal to:
+``` cpp
+is_nothrow_invocable_r_v<R, T..., ArgTypes...>
+```
+Otherwise, *`is-invocable-using`*`<T...>` is equal to:
+``` cpp
+is_invocable_r_v<R, T..., ArgTypes...>
+```
+``` cpp
+template<class F> function_ref(F* f) noexcept;
+```
+*Constraints:*
+- `is_function_v<F>` is `true`, and
+- *`is-invocable-using`*`<F>` is `true`.
+*Preconditions:* `f` is not a null pointer.
+*Effects:* Initializes *bound-entity* with `f`, and *thunk-ptr* with the
+address of a function *`thunk`* such that
+*`thunk`*`(`*`bound-entity`*`, `*`call-args`*`...)` is
+expression-equivalent [[defns.expression.equivalent]] to
+`invoke_r<R>(f, `*`call-args`*`...)`.
+``` cpp
+template<class F> constexpr function_ref(F&& f) noexcept;
+```
+Let `T` be `remove_reference_t<F>`.
+*Constraints:*
+- `remove_cvref_t<F>` is not the same type as `function_ref`,
+- `is_member_pointer_v<T>` is `false`, and
+- *`is-invocable-using`*`<cv T&>` is `true`.
+*Effects:* Initializes *bound-entity* with `addressof(f)`, and
+*thunk-ptr* with the address of a function *`thunk`* such that
+*`thunk`*`(`*`bound-entity`*`, `*`call-args`*`...)` is
+expression-equivalent [[defns.expression.equivalent]] to
+`invoke_r<R>(static_cast<cv T&>(f), `*`call-args`*`...)`.
+``` cpp
+template<auto f> constexpr function_ref(nontype_t<f>) noexcept;
+```
+Let `F` be `decltype(f)`.
+*Constraints:* *`is-invocable-using`*`<F>` is `true`.
+*Mandates:* If `is_pointer_v<F> || is_member_pointer_v<F>` is `true`,
+then `f != nullptr` is `true`.
+*Effects:* Initializes *bound-entity* with a pointer to an unspecified
+object or null pointer value, and *thunk-ptr* with the address of a
+function *`thunk`* such that
+*`thunk`*`(`*`bound-entity`*`, `*`call-args`*`...)` is
+expression-equivalent [[defns.expression.equivalent]] to
+`invoke_r<R>(f, `*`call-args`*`...)`.
+``` cpp
+template<auto f, class U>
+  constexpr function_ref(nontype_t<f>, U&& obj) noexcept;
+```
+Let `T` be `remove_reference_t<U>` and `F` be `decltype(f)`.
+*Constraints:*
+- `is_rvalue_reference_v<U&&>` is `false`, and
+- *`is-invocable-using`*`<F, cv T&>` is `true`.
+*Mandates:* If `is_pointer_v<F> || is_member_pointer_v<F>` is `true`,
+then `f != nullptr` is `true`.
+*Effects:* Initializes *bound-entity* with `addressof(obj)`, and
+*thunk-ptr* with the address of a function *`thunk`* such that
+*`thunk`*`(`*`bound-entity`*`, `*`call-args`*`...)` is
+expression-equivalent [[defns.expression.equivalent]] to
+`invoke_r<R>(f, static_cast<cv T&>(obj), `*`call-args`*`...)`.
+``` cpp
+template<auto f, class T>
+  constexpr function_ref(nontype_t<f>, cv T* obj) noexcept;
+```
+Let `F` be `decltype(f)`.
+*Constraints:* *`is-invocable-using`*`<F, cv T*>` is `true`.
+*Mandates:* If `is_pointer_v<F> || is_member_pointer_v<F>` is `true`,
+then `f != nullptr` is `true`.
+*Preconditions:* If `is_member_pointer_v<F>` is `true`, `obj` is not a
+null pointer.
+*Effects:* Initializes *bound-entity* with `obj`, and *thunk-ptr* with
+the address of a function *`thunk`* such that
+*`thunk`*`(`*`bound-entity`*`, `*`call-args`*`...)` is
+expression-equivalent [[defns.expression.equivalent]] to
+`invoke_r<R>(f, obj, `*`call-args`*`...)`.
+``` cpp
+template<class T> function_ref& operator=(T) = delete;
+```
+*Constraints:*
+- `T` is not the same type as `function_ref`,
+- `is_pointer_v<T>` is `false`, and
+- `T` is not a specialization of `nontype_t`.
+##### Invocation <a id="func.wrap.ref.inv">[[func.wrap.ref.inv]]</a>
+``` cpp
+R operator()(ArgTypes... args) const noexcept(noex);
+```
+*Effects:* Equivalent to:
+`return `*`thunk-ptr`*`(`*`bound-entity`*`, std::forward<ArgTypes>(args)...);`
+##### Deduction guides <a id="func.wrap.ref.deduct">[[func.wrap.ref.deduct]]</a>
+``` cpp
+template<class F>
+  function_ref(F*) -> function_ref<F>;
+```
+*Constraints:* `is_function_v<F>` is `true`.
+``` cpp
+template<auto f>
+  function_ref(nontype_t<f>) -> function_ref<see below>;
+```
+Let `F` be `remove_pointer_t<decltype(f)>`.
+*Constraints:* `is_function_v<F>` is `true`.
+*Remarks:* The deduced type is `function_ref<F>`.
+``` cpp
+template<auto f, class T>
+  function_ref(nontype_t<f>, T&&) -> function_ref<see below>;
+```
+Let `F` be `decltype(f)`.
+*Constraints:*
+- `F` is of the form `R(G::*)(A...) cv `\\ₒₚₜ ` noexcept(E)` for a type
+  `G`, or
+- `F` is of the form `M G::*` for a type `G` and an object type `M`, in
+  which case let `R` be `invoke_result_t<F, T&>`, `A...` be an empty
+  pack, and `E` be `false`, or
+- `F` is of the form `R(*)(G, A...) noexcept(E)` for a type `G`.
+*Remarks:* The deduced type is `function_ref<R(A...) noexcept(E)>`.
 ### Searchers <a id="func.search">[[func.search]]</a>
 #### General <a id="func.search.general">[[func.search.general]]</a>
 Subclause [[func.search]] provides function object types
                      Hash hf = Hash(),
                      BinaryPredicate pred = BinaryPredicate());
 ```
 *Preconditions:* The value type of `RandomAccessIterator1` meets the
+*Cpp17DefaultConstructible*, *Cpp17CopyConstructible*, and
 *Cpp17CopyAssignable* requirements.
 Let `V` be `iterator_traits<RandomAccessIterator1>::value_type`. For any
 two values `A` and `B` of type `V`, if `pred(A, B) == true`, then
 `hf(A) == hf(B)` is `true`.
 - meet the requirement that the expression `h(k)`, where `h` is an
   object of type `hash<Key>` and `k` is an object of type `Key`, shall
   not throw an exception unless `hash<Key>` is a program-defined
   specialization.
 ## Bit manipulation <a id="bit">[[bit]]</a>
 ### General <a id="bit.general">[[bit.general]]</a>
 The header `<bit>` provides components to access, manipulate and process
   template<class T>
     constexpr int bit_width(T x) noexcept;
   // [bit.rotate], rotating
   template<class T>
+    constexpr T rotl(T x, int s) noexcept;
   template<class T>
+    constexpr T rotr(T x, int s) noexcept;
   // [bit.count], counting
   template<class T>
     constexpr int countl_zero(T x) noexcept;
   template<class T>
 - `sizeof(To) == sizeof(From)` is `true`;
 - `is_trivially_copyable_v<To>` is `true`; and
 - `is_trivially_copyable_v<From>` is `true`.
+*Mandates:* Neither `To` nor `From` are consteval-only
+types [[basic.types.general]].
+`To`, `From`, and the types of all subobjects of `To` and `From` are
+types `T` such that:
+- `is_union_v<T>` is `false`;
+- `is_pointer_v<T>` is `false`;
+- `is_member_pointer_v<T>` is `false`;
+- `is_volatile_v<T>` is `false`; and
+- `T` has no non-static data members of reference type.
 *Returns:* An object of type `To`. Implicitly creates objects nested
 within the result [[intro.object]]. Each bit of the value representation
 of the result is equal to the corresponding bit in the object
 representation of `from`. Padding bits of the result are unspecified.
 For the result and each object created within it, if there is no value
 of the object’s type corresponding to the value representation produced,
 the behavior is undefined. If there are multiple such values, which
 value is produced is unspecified. A bit in the value representation of
 the result is indeterminate if it does not correspond to a bit in the
+value representation of `from` or corresponds to a bit for which the
+smallest enclosing object is not within its lifetime or has an
+indeterminate value [[basic.indet]]. A bit in the value representation
+of the result is erroneous if it corresponds to a bit for which the
+smallest enclosing object has an erroneous value. For each bit b in the
+value representation of the result that is indeterminate or erroneous,
+let u be the smallest object containing that bit enclosing b:
+- If u is of unsigned ordinary character type or `std::byte` type, u has
+  an indeterminate value if any of the bits in its value representation
+  are indeterminate, or otherwise has an erroneous value.
+- Otherwise, if b is indeterminate, the behavior is undefined.
+- Otherwise, the behavior is erroneous, and the result is as specified
+  above.
+The result does not otherwise contain any indeterminate or erroneous
+values.
 ### `byteswap` <a id="bit.byteswap">[[bit.byteswap]]</a>
 ``` cpp
 template<class T>
 In the following descriptions, let `N` denote
 `numeric_limits<T>::digits`.
 ``` cpp
 template<class T>
+  constexpr T rotl(T x, int s) noexcept;
 ```
 *Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
 Let `r` be `s % N`.
 *Returns:* If `r` is `0`, `x`; if `r` is positive,
 `(x << r) | (x >> (N - r))`; if `r` is negative, `rotr(x, -r)`.
 ``` cpp
 template<class T>
+  constexpr T rotr(T x, int s) noexcept;
 ```
 *Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
 Let `r` be `s % N`.
 big-endian, `endian::native` is equal to `endian::big`. If all scalar
 types are little-endian, `endian::native` is equal to `endian::little`.
 Otherwise, `endian::native` is not equal to either `endian::big` or
 `endian::little`.
+## Header `<stdbit.h>` synopsis <a id="stdbit.h.syn">[[stdbit.h.syn]]</a>
+``` cpp
+// all freestanding
+#define __STDC_VERSION_STDBIT_H__ 202311L
+#define __STDC_ENDIAN_BIG__     see below
+#define __STDC_ENDIAN_LITTLE__  see below
+#define __STDC_ENDIAN_NATIVE__  see below
+unsigned int stdc_leading_zeros_uc(unsigned char value);
+unsigned int stdc_leading_zeros_us(unsigned short value);
+unsigned int stdc_leading_zeros_ui(unsigned int value);
+unsigned int stdc_leading_zeros_ul(unsigned long int value);
+unsigned int stdc_leading_zeros_ull(unsigned long long int value);
+template<class T> see below stdc_leading_zeros(T value);
+unsigned int stdc_leading_ones_uc(unsigned char value);
+unsigned int stdc_leading_ones_us(unsigned short value);
+unsigned int stdc_leading_ones_ui(unsigned int value);
+unsigned int stdc_leading_ones_ul(unsigned long int value);
+unsigned int stdc_leading_ones_ull(unsigned long long int value);
+template<class T> see below stdc_leading_ones(T value);
+unsigned int stdc_trailing_zeros_uc(unsigned char value);
+unsigned int stdc_trailing_zeros_us(unsigned short value);
+unsigned int stdc_trailing_zeros_ui(unsigned int value);
+unsigned int stdc_trailing_zeros_ul(unsigned long int value);
+unsigned int stdc_trailing_zeros_ull(unsigned long long int value);
+template<class T> see below stdc_trailing_zeros(T value);
+unsigned int stdc_trailing_ones_uc(unsigned char value);
+unsigned int stdc_trailing_ones_us(unsigned short value);
+unsigned int stdc_trailing_ones_ui(unsigned int value);
+unsigned int stdc_trailing_ones_ul(unsigned long int value);
+unsigned int stdc_trailing_ones_ull(unsigned long long int value);
+template<class T> see below stdc_trailing_ones(T value);
+unsigned int stdc_first_leading_zero_uc(unsigned char value);
+unsigned int stdc_first_leading_zero_us(unsigned short value);
+unsigned int stdc_first_leading_zero_ui(unsigned int value);
+unsigned int stdc_first_leading_zero_ul(unsigned long int value);
+unsigned int stdc_first_leading_zero_ull(unsigned long long int value);
+template<class T> see below stdc_first_leading_zero(T value);
+unsigned int stdc_first_leading_one_uc(unsigned char value);
+unsigned int stdc_first_leading_one_us(unsigned short value);
+unsigned int stdc_first_leading_one_ui(unsigned int value);
+unsigned int stdc_first_leading_one_ul(unsigned long int value);
+unsigned int stdc_first_leading_one_ull(unsigned long long int value);
+template<class T> see below stdc_first_leading_one(T value);
+unsigned int stdc_first_trailing_zero_uc(unsigned char value);
+unsigned int stdc_first_trailing_zero_us(unsigned short value);
+unsigned int stdc_first_trailing_zero_ui(unsigned int value);
+unsigned int stdc_first_trailing_zero_ul(unsigned long int value);
+unsigned int stdc_first_trailing_zero_ull(unsigned long long int value);
+template<class T> see below stdc_first_trailing_zero(T value);
+unsigned int stdc_first_trailing_one_uc(unsigned char value);
+unsigned int stdc_first_trailing_one_us(unsigned short value);
+unsigned int stdc_first_trailing_one_ui(unsigned int value);
+unsigned int stdc_first_trailing_one_ul(unsigned long int value);
+unsigned int stdc_first_trailing_one_ull(unsigned long long int value);
+template<class T> see below stdc_first_trailing_one(T value);
+unsigned int stdc_count_zeros_uc(unsigned char value);
+unsigned int stdc_count_zeros_us(unsigned short value);
+unsigned int stdc_count_zeros_ui(unsigned int value);
+unsigned int stdc_count_zeros_ul(unsigned long int value);
+unsigned int stdc_count_zeros_ull(unsigned long long int value);
+template<class T> see below stdc_count_zeros(T value);
+unsigned int stdc_count_ones_uc(unsigned char value);
+unsigned int stdc_count_ones_us(unsigned short value);
+unsigned int stdc_count_ones_ui(unsigned int value);
+unsigned int stdc_count_ones_ul(unsigned long int value);
+unsigned int stdc_count_ones_ull(unsigned long long int value);
+template<class T> see below stdc_count_ones(T value);
+bool stdc_has_single_bit_uc(unsigned char value);
+bool stdc_has_single_bit_us(unsigned short value);
+bool stdc_has_single_bit_ui(unsigned int value);
+bool stdc_has_single_bit_ul(unsigned long int value);
+bool stdc_has_single_bit_ull(unsigned long long int value);
+template<class T> bool stdc_has_single_bit(T value);
+unsigned int stdc_bit_width_uc(unsigned char value);
+unsigned int stdc_bit_width_us(unsigned short value);
+unsigned int stdc_bit_width_ui(unsigned int value);
+unsigned int stdc_bit_width_ul(unsigned long int value);
+unsigned int stdc_bit_width_ull(unsigned long long int value);
+template<class T> see below stdc_bit_width(T value);
+unsigned char stdc_bit_floor_uc(unsigned char value);
+unsigned short stdc_bit_floor_us(unsigned short value);
+unsigned int stdc_bit_floor_ui(unsigned int value);
+unsigned long int stdc_bit_floor_ul(unsigned long int value);
+unsigned long long int stdc_bit_floor_ull(unsigned long long int value);
+template<class T> T stdc_bit_floor(T value);
+unsigned char stdc_bit_ceil_uc(unsigned char value);
+unsigned short stdc_bit_ceil_us(unsigned short value);
+unsigned int stdc_bit_ceil_ui(unsigned int value);
+unsigned long int stdc_bit_ceil_ul(unsigned long int value);
+unsigned long long int stdc_bit_ceil_ull(unsigned long long int value);
+template<class T> T stdc_bit_ceil(T value);
+```
+For a function template whose return type is not specified above, the
+return type is an *implementation-defined* unsigned integer type large
+enough to represent all possible result values. Each function template
+has the same semantics as the corresponding type-generic function with
+the same name specified in See also: ISO C 7.18.
+*Mandates:* `T` is an unsigned integer type.
+Otherwise, the contents and meaning of the header `<stdbit.h>` are the
+same as the C standard library header `<stdbit.h>`.
+See also: ISO C 7.18
 <!-- Link reference definitions -->
 [algorithms]: algorithms.md#algorithms
 [algorithms.general]: algorithms.md#algorithms.general
 [allocator.requirements.general]: library.md#allocator.requirements.general
 [allocator.uses.construction]: mem.md#allocator.uses.construction
 [any]: #any
 [any.assign]: #any.assign
 [any.bad.any.cast]: #any.bad.any.cast
 [arithmetic.operations.minus]: #arithmetic.operations.minus
 [arithmetic.operations.modulus]: #arithmetic.operations.modulus
 [arithmetic.operations.multiplies]: #arithmetic.operations.multiplies
 [arithmetic.operations.negate]: #arithmetic.operations.negate
 [arithmetic.operations.plus]: #arithmetic.operations.plus
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.indet]: basic.md#basic.indet
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.types.general]: basic.md#basic.types.general
 [bit]: #bit
 [bit.endian]: #bit.endian
 [bit.general]: #bit.general
 [bit.pow.two]: #bit.pow.two
 [bit.rotate]: #bit.rotate
 [bit.syn]: #bit.syn
 [bitset]: #bitset
 [bitset.cons]: #bitset.cons
 [bitset.hash]: #bitset.hash
 [bitset.members]: #bitset.members
 [bitset.operators]: #bitset.operators
 [bitwise.operations.and]: #bitwise.operations.and
 [bitwise.operations.general]: #bitwise.operations.general
 [bitwise.operations.not]: #bitwise.operations.not
 [bitwise.operations.or]: #bitwise.operations.or
 [bitwise.operations.xor]: #bitwise.operations.xor
 [class.base.init]: class.md#class.base.init
 [class.copy.ctor]: class.md#class.copy.ctor
 [comparisons]: #comparisons
 [comparisons.equal.to]: #comparisons.equal.to
 [comparisons.general]: #comparisons.general
 [comparisons.less]: #comparisons.less
 [comparisons.less.equal]: #comparisons.less.equal
 [comparisons.not.equal.to]: #comparisons.not.equal.to
 [comparisons.three.way]: #comparisons.three.way
 [concepts.equality]: concepts.md#concepts.equality
+[container.reqmts]: containers.md#container.reqmts
 [cpp17.copyassignable]: #cpp17.copyassignable
 [cpp17.defaultconstructible]: #cpp17.defaultconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cpp17.hash]: #cpp17.hash
 [cpp17.moveassignable]: #cpp17.moveassignable
 [cpp17.moveconstructible]: #cpp17.moveconstructible
 [dcl.constexpr]: dcl.md#dcl.constexpr
 [dcl.init.general]: dcl.md#dcl.init.general
 [declval]: #declval
 [defns.expression.equivalent]: intro.md#defns.expression.equivalent
 [defns.order.ptr]: #defns.order.ptr
 [defns.referenceable]: intro.md#defns.referenceable
 [expected]: #expected
 [expected.bad]: #expected.bad
 [expected.bad.void]: #expected.bad.void
 [expected.expected]: #expected.expected
 [expected.general]: #expected.general
 [expr.mul]: expr.md#expr.mul
 [expr.or]: expr.md#expr.or
 [expr.rel]: expr.md#expr.rel
 [expr.unary.op]: expr.md#expr.unary.op
 [expr.xor]: expr.md#expr.xor
 [forward]: #forward
 [freestanding.item]: library.md#freestanding.item
 [func.bind]: #func.bind
 [func.bind.bind]: #func.bind.bind
 [func.bind.general]: #func.bind.general
 [func.search.bmh]: #func.search.bmh
 [func.search.default]: #func.search.default
 [func.search.general]: #func.search.general
 [func.wrap]: #func.wrap
 [func.wrap.badcall]: #func.wrap.badcall
+[func.wrap.copy]: #func.wrap.copy
+[func.wrap.copy.class]: #func.wrap.copy.class
+[func.wrap.copy.ctor]: #func.wrap.copy.ctor
+[func.wrap.copy.general]: #func.wrap.copy.general
+[func.wrap.copy.inv]: #func.wrap.copy.inv
+[func.wrap.copy.util]: #func.wrap.copy.util
 [func.wrap.func]: #func.wrap.func
 [func.wrap.func.alg]: #func.wrap.func.alg
 [func.wrap.func.cap]: #func.wrap.func.cap
 [func.wrap.func.con]: #func.wrap.func.con
 [func.wrap.func.general]: #func.wrap.func.general
 [func.wrap.move.class]: #func.wrap.move.class
 [func.wrap.move.ctor]: #func.wrap.move.ctor
 [func.wrap.move.general]: #func.wrap.move.general
 [func.wrap.move.inv]: #func.wrap.move.inv
 [func.wrap.move.util]: #func.wrap.move.util
+[func.wrap.ref]: #func.wrap.ref
+[func.wrap.ref.class]: #func.wrap.ref.class
+[func.wrap.ref.ctor]: #func.wrap.ref.ctor
+[func.wrap.ref.deduct]: #func.wrap.ref.deduct
+[func.wrap.ref.general]: #func.wrap.ref.general
+[func.wrap.ref.inv]: #func.wrap.ref.inv
 [function.objects]: #function.objects
 [function.objects.general]: #function.objects.general
 [functional.syn]: #functional.syn
+[intro.abstract]: intro.md#intro.abstract
 [intro.multithread]: basic.md#intro.multithread
 [intro.object]: basic.md#intro.object
 [invalid.argument]: diagnostics.md#invalid.argument
 [istream.formatted]: input.md#istream.formatted
+[iterator.concept.contiguous]: iterators.md#iterator.concept.contiguous
+[iterator.requirements.general]: iterators.md#iterator.requirements.general
+[lex.ccon]: lex.md#lex.ccon
 [logical.operations]: #logical.operations
 [logical.operations.and]: #logical.operations.and
 [logical.operations.general]: #logical.operations.general
 [logical.operations.not]: #logical.operations.not
 [logical.operations.or]: #logical.operations.or
 [meta.rqmts]: meta.md#meta.rqmts
 [meta.trans.other]: meta.md#meta.trans.other
 [optional]: #optional
 [optional.assign]: #optional.assign
 [optional.assign.copy]: #optional.assign.copy
 [optional.assign.copy.templ]: #optional.assign.copy.templ
 [optional.assign.move]: #optional.assign.move
 [optional.comp.with.t]: #optional.comp.with.t
 [optional.ctor]: #optional.ctor
 [optional.dtor]: #optional.dtor
 [optional.general]: #optional.general
 [optional.hash]: #optional.hash
+[optional.iterators]: #optional.iterators
 [optional.mod]: #optional.mod
 [optional.monadic]: #optional.monadic
 [optional.nullops]: #optional.nullops
 [optional.nullopt]: #optional.nullopt
 [optional.observe]: #optional.observe
 [optional.optional]: #optional.optional
 [optional.optional.general]: #optional.optional.general
+[optional.optional.ref]: #optional.optional.ref
+[optional.optional.ref.general]: #optional.optional.ref.general
+[optional.ref.assign]: #optional.ref.assign
+[optional.ref.ctor]: #optional.ref.ctor
+[optional.ref.expos]: #optional.ref.expos
+[optional.ref.iterators]: #optional.ref.iterators
+[optional.ref.mod]: #optional.ref.mod
+[optional.ref.monadic]: #optional.ref.monadic
+[optional.ref.observe]: #optional.ref.observe
+[optional.ref.swap]: #optional.ref.swap
 [optional.relops]: #optional.relops
 [optional.specalg]: #optional.specalg
 [optional.swap]: #optional.swap
 [optional.syn]: #optional.syn
 [ostream.formatted]: input.md#ostream.formatted
 [pair.piecewise]: #pair.piecewise
 [pairs]: #pairs
 [pairs.general]: #pairs.general
 [pairs.pair]: #pairs.pair
 [pairs.spec]: #pairs.spec
+[random.access.iterators]: iterators.md#random.access.iterators
 [range.cmp]: #range.cmp
 [range.utility.helpers]: ranges.md#range.utility.helpers
 [refwrap]: #refwrap
 [refwrap.access]: #refwrap.access
 [refwrap.assign]: #refwrap.assign
 [refwrap.common.ref]: #refwrap.common.ref
+[refwrap.comparisons]: #refwrap.comparisons
 [refwrap.const]: #refwrap.const
 [refwrap.general]: #refwrap.general
 [refwrap.helpers]: #refwrap.helpers
 [refwrap.invoke]: #refwrap.invoke
+[stdbit.h.syn]: #stdbit.h.syn
 [support.signal]: support.md#support.signal
 [swappable.requirements]: library.md#swappable.requirements
+[temp.constr.atomic]: temp.md#temp.constr.atomic
+[temp.point]: temp.md#temp.point
 [temp.type]: temp.md#temp.type
 [template.bitset]: #template.bitset
 [template.bitset.general]: #template.bitset.general
 [term.object.representation]: basic.md#term.object.representation
 [term.object.type]: basic.md#term.object.type
 [term.odr.use]: basic.md#term.odr.use
 [term.perfect.forwarding.call.wrapper]: #term.perfect.forwarding.call.wrapper
 [term.simple.call.wrapper]: #term.simple.call.wrapper
+[term.structural.type]: temp.md#term.structural.type
 [term.trivially.copyable.type]: basic.md#term.trivially.copyable.type
 [term.unevaluated.operand]: expr.md#term.unevaluated.operand
 [tuple]: #tuple
 [tuple.apply]: #tuple.apply
 [tuple.assign]: #tuple.assign
 [tuple.cnstr]: #tuple.cnstr
 [tuple.common.ref]: #tuple.common.ref
 [tuple.special]: #tuple.special
 [tuple.swap]: #tuple.swap
 [tuple.syn]: #tuple.syn
 [tuple.traits]: #tuple.traits
 [tuple.tuple]: #tuple.tuple
+[tuple.tuple.general]: #tuple.tuple.general
 [unord]: containers.md#unord
 [unord.hash]: #unord.hash
 [utilities]: #utilities
 [utilities.general]: #utilities.general
 [utilities.summary]: #utilities.summary
 [utility.as.const]: #utility.as.const
 [utility.exchange]: #utility.exchange
 [utility.intcmp]: #utility.intcmp
 [utility.swap]: #utility.swap
 [utility.syn]: #utility.syn
+[utility.undefined]: #utility.undefined
 [utility.underlying]: #utility.underlying
 [variant]: #variant
 [variant.assign]: #variant.assign
 [variant.bad.access]: #variant.bad.access
 [variant.ctor]: #variant.ctor
 [variant.dtor]: #variant.dtor
 [variant.visit]: #variant.visit
 [^1]: Such a type is a function pointer or a class type which has a
     member `operator()` or a class type which has a conversion to a
     pointer to function.

Diff to HTML by rtfpessoa