[format] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpwssptnoo/{from.md → to.md} +222 -90

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

@@ -16,10 +16,21 @@ namespace std {
   // [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>...>;
@@ -85,10 +96,14 @@ namespace std {
     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>
@@ -136,26 +151,27 @@ namespace std {
   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;
 }
 ```
@@ -164,11 +180,11 @@ 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
@@ -214,11 +230,11 @@ 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
@@ -263,14 +279,14 @@ 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*]
@@ -325,11 +341,11 @@ precision
     '.' '{' 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
@@ -372,20 +388,22 @@ 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>
@@ -437,15 +455,16 @@ 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;
@@ -460,13 +479,13 @@ string s4 = format("{:06}", inf);       // value of s4 is "\ \ \ inf" (0 has no
 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.
@@ -475,25 +494,25 @@ 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.
@@ -583,13 +602,13 @@ 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]].
@@ -635,10 +654,11 @@ are specified in [[format.type.ptr]].
 **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
@@ -656,10 +676,11 @@ namespace std {
   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; }
   };
 }
 ```
@@ -906,12 +927,12 @@ argument type `T`, in [[formatter.basic]] and [[formatter]]:
 - `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>
@@ -920,10 +941,22 @@ messages. — *end note*]
 | ----------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `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]].
@@ -939,11 +972,11 @@ template<class T, class Context,
       { 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
@@ -991,16 +1024,37 @@ enabled specializations:
   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.
@@ -1022,10 +1076,11 @@ An enabled specialization `formatter<T, charT>` meets the 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*> {
@@ -1115,18 +1170,21 @@ the escaped string representation of a string of *C*, except that:
 [*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>
@@ -1135,11 +1193,11 @@ string s8 = format("[{:?}]", "\\\u0301");           // s8 has value: ["\ \ \ u{3
 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
@@ -1147,37 +1205,49 @@ namespace std {
     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;
 ```
@@ -1207,12 +1277,14 @@ constexpr size_t next_arg_id();
 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]].
@@ -1225,25 +1297,67 @@ constexpr void check_arg_id(size_t id);
 ``` 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>;
@@ -1257,10 +1371,14 @@ namespace std {
 ```
 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
@@ -1307,33 +1425,34 @@ 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"
 ```
@@ -1492,15 +1611,17 @@ closing-bracket_ = closing;
 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*,
@@ -1765,11 +1886,11 @@ namespace std {
   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>,
@@ -1779,10 +1900,15 @@ namespace std {
   public:
     basic_format_arg() noexcept;
     explicit operator bool() const noexcept;
   };
 }
 ```
 An instance of `basic_format_arg` provides access to a formatting
@@ -1802,17 +1928,17 @@ 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
@@ -1843,10 +1969,26 @@ is ill-formed unless the user provides an enabled specialization of
 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>
@@ -1855,12 +1997,10 @@ namespace std {
     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;
   };
 }
 ```
@@ -1893,18 +2033,10 @@ Let
 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>
@@ -1916,25 +2048,25 @@ namespace std {
 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...);`
@@ -1946,12 +2078,10 @@ namespace std {
   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;
   };
@@ -1960,22 +2090,19 @@ namespace std {
     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;
 ```
@@ -2015,10 +2142,14 @@ namespace std {
     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
@@ -2084,16 +2215,17 @@ closing-bracket_ = closing;
 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>
@@ -2123,26 +2255,26 @@ the *tuple-format-spec*:
 ``` 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`.

   // [format.fmt.string], class template basic_format_string
   template<class charT, class... Args>
     struct basic_format_string;
+  template<class charT> struct runtime-format-string {                  // exposition only
+  private:
+    basic_string_view<charT> str;                                       // exposition only
+  public:
+    runtime-format-string(basic_string_view<charT> s) noexcept : str(s) {}
+    runtime-format-string(const runtime-format-string&) = delete;
+    runtime-format-string& operator=(const runtime-format-string&) = delete;
+  };
+  runtime-format-string<char> runtime_format(string_view fmt) noexcept { return fmt; }
+  runtime-format-string<wchar_t> runtime_format(wstring_view fmt) noexcept { return fmt; }
   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>...>;
     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.formatter.locking], formatter locking
+  template<class T>
+    constexpr bool enable_nonlocking_formatter_optimization = false;
   // [format.formattable], concept formattable
   template<class T, class charT>
     concept formattable = see below;
   template<class R, class charT>
   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> { };
+  template<ranges::input_range R>
+    requires (format_kind<R> != range_format::disabled)
+    constexpr bool enable_nonlocking_formatter_optimization<R> = false;
   // [format.arguments], arguments
   // [format.arg], class template basic_format_arg
   template<class Context> class basic_format_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;
 }
 ```
 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>
+#### 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
     ':' format-spec
 ```
 ``` bnf
 format-spec
+    as specified by the formatter specialization for the argument type; cannot start with '}'
 ```
 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
 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*]
     '.' '{' arg-idₒₚₜ '}'
 ```
 ``` bnf
 type one of
+    'a A b B c d e E f F g G o p 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
 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"
+string sB = format("{:\importexample[-2pt]{example_05}\kern0.75pt^6}", "x");         // value of sB is "\importexample[-2pt]{example_05\importexample[-2pt]{example_05}x\importexample[-2pt]{example_05}\importexample[-2pt]{example_05}\importexample[-2pt]{example_05}"}
+string sC = format("{:*^6}", "\importexample[-2pt]{example_05}\kern0.75pt\importexample[-2pt]{example_05}\kern0.75pt\importexample[-2pt]{example_05}\kern0.75pt");     // value of sC is "\importexample[-2pt]{example_05\importexample[-2pt]{example_05}\importexample[-2pt]{example_05}"}
 ```
 — *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>
 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`, pointer types, 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;
 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. The option is valid only if the corresponding formatting
+argument is of standard signed or unsigned integer type. If 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.
 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®-based[^25]
+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"` 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.
 [[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]] with `value` converted to the unsigned version of the underlying type. |
 | % `?`                          | 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 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. |
+| `P`       | The same as `p`, except that it uses uppercase letters for digits above `9` and the base prefix is `0X`.                                                                                                                                 |
 ### Error reporting <a id="format.err.report">[[format.err.report]]</a>
 Formatting functions throw `format_error` if an argument `fmt` is passed
   private:
     basic_string_view<charT> str;         // exposition only
   public:
     template<class T> consteval basic_format_string(const T& s);
+    basic_format_string(runtime-format-string<charT> s) noexcept : str(s.str) {}
     constexpr basic_string_view<charT> get() const noexcept { return str; }
   };
 }
 ```
 - `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 not present or 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>
 | ----------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `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`.                                                                                                                                                                                                                                                                                                          |
+#### Formatter locking <a id="format.formatter.locking">[[format.formatter.locking]]</a>
+``` cpp
+template<class T>
+  constexpr bool enable_nonlocking_formatter_optimization = false;
+```
+*Remarks:* Pursuant to [[namespace.std]], users may specialize
+`enable_nonlocking_formatter_optimization` for cv-unqualified
+program-defined types. Such specializations shall be usable in constant
+expressions [[expr.const]] and have type `const bool`.
 #### 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]].
       { 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>, 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
   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]].
+Unless specified otherwise, for each type `T` for which a `formatter`
+specialization is provided by the library, each of the headers provides
+the following specialization:
+``` cpp
+template<> inline constexpr bool enable_nonlocking_formatter_optimization<T> = true;
+```
+[*Note 1*: Specializations such as `formatter<wchar_t, char>` that
+would require implicit multibyte / wide string or character conversion
+are disabled. — *end note*]
+The header `<format>` provides the following disabled specializations:
+- The string type specializations
+  ``` cpp
+  template<> struct formatter<char*, wchar_t>;
+  template<> struct formatter<const char*, wchar_t>;
+  template<size_t N> struct formatter<char[N], wchar_t>;
+  template<class traits, class Allocator>
+    struct formatter<basic_string<char, traits, Allocator>, wchar_t>;
+  template<class traits>
+    struct formatter<basic_string_view<char, traits>, wchar_t>;
+  ```
 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.
 [*Example 1*:
 ``` cpp
 #include <format>
+#include <string>
 enum color { red, green, blue };
 const char* color_names[] = { "red", "green", "blue" };
 template<> struct std::formatter<color> : std::formatter<const char*> {
 [*Example 1*:
 ``` cpp
 string s0 = format("[{}]", "h\tllo");                   // s0 has value: [h\ \ \ \ llo]
 string s1 = format("[{:?}]", "h\tllo");                 // s1 has value: ["h\ tllo"]
+string s2 = format("[{:?}]", "\importexample[-2.5pt]{example_01}");  \kern1.25pt// s2 has value: ["\importexample[-2.5pt]{example_01"]}
 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 s6 = format("[{:?}]", "\importexample{example_02}");                 \kern0.75pt// s6 has value: ["\importexample{example_03{u}{200d}\importexample{example_04}"]}
+string s7 = format("[{:?}]", "\u0301"); // s7 has value: ["\ u{301\"]}
+string s8 = format("[{:?}]", "\\\u0301");           // s8 has value: ["\ \ \ u{301\"]}
+string s9 = format("[{:?}]", "e\u0301\u0323");      // s9 has value: ["\importexample[-2pt]{example_06"]}
 ```
 — *end example*]
 #### Class template `basic_format_parse_context` <a id="format.parse.ctx">[[format.parse.ctx]]</a>
 namespace std {
   template<class charT>
   class basic_format_parse_context {
   public:
     using char_type = charT;
+    using const_iterator = basic_string_view<charT>::const_iterator;
     using iterator = const_iterator;
   private:
     iterator begin_;                                    // exposition only
     iterator end_;                                      // 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) 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);
+    template<class... Ts>
+      constexpr void check_dynamic_spec(size_t id) noexcept;
+    constexpr void check_dynamic_spec_integral(size_t id) noexcept;
+    constexpr void check_dynamic_spec_string(size_t id) noexcept;
   };
 }
 ```
 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.
+If a program declares an explicit or partial specialization of
+`basic_format_parse_context`, the program is ill-formed, no diagnostic
+required.
 ``` cpp
+constexpr explicit basic_format_parse_context(basic_string_view<charT> fmt) noexcept;
 ```
 *Effects:* Initializes `begin_` with `fmt.begin()`, `end_` with
 `fmt.end()`, `indexing_` with `unknown`, `next_arg_id_` with `0`, and
+`num_args_` with `0`.
+[*Note 1*: Any call to `next_arg_id`, `check_arg_id`, or
+`check_dynamic_spec` on an instance of `basic_format_parse_context`
+initialized using this constructor is not a core constant
+expression. — *end note*]
 ``` cpp
 constexpr const_iterator begin() const noexcept;
 ```
 if (indexing_ == unknown)
   indexing_ = automatic;
 return next_arg_id_++;
 ```
+*Throws:* `format_error` if `indexing_ == manual` is `true`.
+[*Note 2*: This indicates mixing of automatic and manual argument
+indexing. — *end note*]
 *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
 if (indexing_ == unknown)
   indexing_ = manual;
 ```
+*Throws:* `format_error` if `indexing_ == automatic` is `true`.
+[*Note 3*: This indicates mixing of automatic and manual argument
+indexing. — *end note*]
+*Remarks:* A call to this function is a core constant
+expression [[expr.const]] only if `id < num_args_` is `true`.
+``` cpp
+template<class... Ts>
+  constexpr void check_dynamic_spec(size_t id) noexcept;
+```
+*Mandates:* `sizeof...(Ts)` ≥ 1. The types in `Ts...` are unique. Each
+type in `Ts...` is one of `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>`, or
+`const void*`.
+*Remarks:* A call to this function is a core constant expression only if
+- `id < num_args_` is `true` and
+- the type of the corresponding format argument (after conversion to
+  `basic_format_arg<Context>`) is one of the types in `Ts...`.
+``` cpp
+constexpr void check_dynamic_spec_integral(size_t id) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+check_dynamic_spec<int, unsigned int, long long int, unsigned long long int>(id);
+```
+``` cpp
+constexpr void check_dynamic_spec_string(size_t id) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+check_dynamic_spec<const char_type*, basic_string_view<char_type>>(id);
+```
 #### 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
+    basic_format_context(const basic_format_context&) = delete;
+    basic_format_context& operator=(const basic_format_context&) = delete;
   public:
     using iterator = Out;
     using char_type = charT;
     template<class T> using formatter_type = formatter<T, charT>;
 ```
 An instance of `basic_format_context` holds formatting state consisting
 of the formatting arguments and the output iterator.
+If a program declares an explicit or partial specialization of
+`basic_format_context`, the program is ill-formed, no diagnostic
+required.
 `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
   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 is_digit = [](auto c) { return c >= '0' && c <= '9'; };
     auto get_char = [&]() { return iter != ctx.end() ? *iter : 0; };
     if (get_char() != '{')
       return iter;
     ++iter;
     char c = get_char();
+    if (!is_digit(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 = ctx.arg(width_arg_id).visit([](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;
+      });
+    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"
 ```
 template<class ParseContext>
   constexpr typename ParseContext::iterator
     parse(ParseContext& ctx);
 ```
+*Effects:* Parses the format specifiers as a *range-format-spec* and
+stores the parsed specifiers in `*this`. Calls
+*`underlying_`*`.parse(ctx)` to parse *format-spec* in
+*range-format-spec* or, if the latter is not present, an empty
+*format-spec*. 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*,
   class basic_format_arg {
   public:
     class handle;
   private:
+    using char_type = 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>,
   public:
     basic_format_arg() noexcept;
     explicit operator bool() const noexcept;
+    template<class Visitor>
+      decltype(auto) visit(this basic_format_arg arg, Visitor&& vis);
+    template<class R, class Visitor>
+      R visit(this basic_format_arg arg, Visitor&& vis);
   };
 }
 ```
 An instance of `basic_format_arg` provides access to a formatting
 ```
 *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 an 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>(static_cast<unsigned char>(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
 explicit operator bool() const noexcept;
 ```
 *Returns:* `!holds_alternative<monostate>(value)`.
+``` cpp
+template<class Visitor>
+  decltype(auto) visit(this basic_format_arg arg, Visitor&& vis);
+```
+*Effects:* Equivalent to:
+`return arg.value.visit(std::forward<Visitor>(vis));`
+``` cpp
+template<class R, class Visitor>
+  R visit(this basic_format_arg arg, Visitor&& vis);
+```
+*Effects:* Equivalent to:
+`return arg.value.visit<R>(std::forward<Visitor>(vis));`
 The class `handle` allows formatting an object of a user-defined type.
 ``` cpp
 namespace std {
   template<class Context>
     void (*format_)(basic_format_parse_context<char_type>&,
                     Context&, const void*);                     // exposition only
     template<class T> explicit handle(T& val) noexcept;         // exposition only
   public:
     void format(basic_format_parse_context<char_type>&, Context& ctx) const;
   };
 }
 ```
 void format(basic_format_parse_context<char_type>& parse_ctx, Context& format_ctx) const;
 ```
 *Effects:* Equivalent to: `format_(parse_ctx, format_ctx, ptr_);`
 #### Class template *`format-arg-store`* <a id="format.arg.store">[[format.arg.store]]</a>
 ``` cpp
 namespace std {
   template<class Context, class... Args>
 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_const_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 basic_format_args {
     size_t size_;                               // exposition only
     const basic_format_arg<Context>* data_;     // exposition only
   public:
     template<class... Args>
       basic_format_args(const format-arg-store<Context, Args...>& store) noexcept;
     basic_format_arg<Context> get(size_t i) const noexcept;
   };
     basic_format_args(format-arg-store<Context, Args...>) -> basic_format_args<Context>;
 }
 ```
 An instance of `basic_format_args` provides access to formatting
+arguments.
+*Recommended practice:* 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
 template<class... Args>
   basic_format_args(const format-arg-store<Context, Args...>& store) noexcept;
 ```
     template<class FormatContext>
       typename FormatContext::iterator
         format(see below& elems, FormatContext& ctx) const;
   };
+  template<class... Ts>
+    constexpr bool enable_nonlocking_formatter_optimization<pair-or-tuple<Ts...>> =
+      (enable_nonlocking_formatter_optimization<Ts> && ...);
 }
 ```
 The `parse` member functions of these formatters interpret the format
 specification as a *tuple-format-spec* according to the following
 template<class ParseContext>
   constexpr typename ParseContext::iterator
     parse(ParseContext& ctx);
 ```
+*Effects:* Parses the format specifiers 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\_*, calls *`e`*`.parse(ctx)` to parse an
+empty *format-spec* and, 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>
 ``` cpp
 namespace std {
   class format_error : public runtime_error {
   public:
+ constexpr explicit format_error(const string& what_arg);
+ constexpr 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
+constexpr format_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
+constexpr format_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.

Diff to HTML by rtfpessoa