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

Files changed (1) hide show

tmp/tmpj614w7us/{from.md → to.md} +1082 -732

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

@@ -2,111 +2,160 @@
 ### Header `<format>` synopsis <a id="format.syn">[[format.syn]]</a>
 ``` cpp
 namespace std {
   // [format.functions], formatting functions
   template<class... Args>
-    string format(string_view fmt, const Args&... args);
   template<class... Args>
-    wstring format(wstring_view fmt, const Args&... args);
   template<class... Args>
-    string format(const locale& loc, string_view fmt, const Args&... args);
   template<class... Args>
-    wstring format(const locale& loc, wstring_view fmt, const 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, string_view fmt, const Args&... args);
   template<class Out, class... Args>
-    Out format_to(Out out, wstring_view fmt, const Args&... args);
   template<class Out, class... Args>
-    Out format_to(Out out, const locale& loc, string_view fmt, const Args&... args);
   template<class Out, class... Args>
-    Out format_to(Out out, const locale& loc, wstring_view fmt, const Args&... args);
   template<class Out>
-    Out vformat_to(Out out, string_view fmt,
-                   format_args_t<type_identity_t<Out>, char> args);
   template<class Out>
-    Out vformat_to(Out out, wstring_view fmt,
-                   format_args_t<type_identity_t<Out>, wchar_t> args);
   template<class Out>
-    Out vformat_to(Out out, const locale& loc, string_view fmt,
-                   format_args_t<type_identity_t<Out>, char> args);
   template<class Out>
-    Out vformat_to(Out out, const locale& loc, wstring_view fmt,
-                   format_args_t<type_identity_t<Out>, wchar_t> 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,
- string_view fmt, const Args&... args);
   template<class Out, class... Args>
     format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
- wstring_view fmt, const 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, string_view fmt,
- const 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, wstring_view fmt,
- const Args&... args);
   template<class... Args>
-    size_t formatted_size(string_view fmt, const Args&... args);
   template<class... Args>
-    size_t formatted_size(wstring_view fmt, const Args&... args);
   template<class... Args>
-    size_t formatted_size(const locale& loc, string_view fmt, const Args&... args);
   template<class... Args>
-    size_t formatted_size(const locale& loc, wstring_view fmt, const Args&... args);
   // [format.formatter], formatter
   template<class T, class charT = char> struct formatter;
   // [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>;
- 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.arguments], arguments
   // [format.arg], class template basic_format_arg
   template<class Context> class basic_format_arg;
   template<class Visitor, class Context>
- see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
   // [format.arg.store], class template format-arg-store
-  template<class Context, class... Args> struct format-arg-store; // exposition only
   template<class Context = format_context, class... Args>
     format-arg-store<Context, Args...>
-      make_format_args(const Args&... args);
   template<class... Args>
     format-arg-store<wformat_context, Args...>
-      make_wformat_args(const Args&... args);
-  // [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>;
-  template<class Out, class charT>
-    using format_args_t = basic_format_args<basic_format_context<Out, charT>>;
   // [format.error], class format_error
   class format_error;
 }
 ```
@@ -198,13 +247,13 @@ manual indexing. — *end note*]
 ``` 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),
-                                            // throws format_error
 string s3 = format("{} to {1}",  "a", "b"); // not a format string (mixing automatic and manual indexing),
-                                            // throws format_error
 ```
 — *end example*]
 The *format-spec* field contains *format specifications* that define how
@@ -226,17 +275,17 @@ by *arg-id*, the string is not a format string for `args`.
 — *end example*]
 #### Standard format specifiers <a id="format.string.std">[[format.string.std]]</a>
-Each `formatter` specializations 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 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
@@ -276,21 +325,40 @@ precision
     '.' '{' arg-idₒₚₜ '}'
 ```
 ``` bnf
 type one of
-    'a A b B c d e E f F g G o p s x X'
 ```
-[*Note 2*: The *fill* character can be any character other than `{` or
-`}`. The presence of a fill character 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 both the fill character and the alignment option are
 absent. — *end note*]
-The *align* specifier applies to all argument types. The meaning of the
 various alignment options is as specified in [[format.align]].
 [*Example 1*:
 ``` cpp
@@ -300,34 +368,49 @@ 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\ \ "
 ```
 — *end example*]
-[*Note 3*: Unless a minimum field width is defined, the field width is
-determined by the size of the content and the alignment option has no
-effect. — *end note*]
 **Table: Meaning of align options** <a id="format.align">[format.align]</a>
 | Option | Meaning                                                                                                                                                                                                                                                                                                      |
-| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `<`    | Forces the field to be aligned to the start of the available space. This is the default for non-arithmetic types, `charT`, and `bool`, unless an integer presentation type is specified. |
-| % `>`  | Forces the field to be aligned to the end of the available space. This is the default for arithmetic types other than `charT` and `bool` or when an integer presentation type is specified. |
-| % `^`  | Forces the field to be centered within the available space by inserting $\bigl\lfloor \frac{n}{2} \bigr\rfloor$ characters before and $\bigl\lceil \frac{n}{2} \bigr\rceil$ characters after the value, where $n$ is the total number of fill characters to insert. |
 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]].
-[*Note 4*: For negative numbers and negative zero the output of
-`to_chars` will already contain the sign so no additional transformation
-is performed. — *end note*]
 The *sign* option applies to floating-point infinity and NaN.
 [*Example 2*:
@@ -353,88 +436,82 @@ 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.
-If `{ \opt{arg-id} }` is used in a *width* or *precision*, the value of
-the corresponding formatting argument is used in its place. If the
-corresponding formatting argument is not of integral type, or its value
-is negative for *precision* or non-positive for *width*, an exception of
-type `format_error` is thrown.
-The *positive-integer* in *width* is a decimal integer defining the
-minimum field width. If *width* is not specified, there is no minimum
-field width, and the field width is determined based on the content of
-the field.
-The *width* of a string is defined as the estimated number of column
-positions appropriate for displaying it in a terminal.
-[*Note 5*: This is similar to the semantics of the POSIX `wcswidth`
-function. — *end note*]
-For the purposes of width computation, a string is assumed to be in a
-locale-independent, implementation-defined encoding. Implementations
-should use a Unicode encoding on platforms capable of displaying Unicode
-text in a terminal.
-[*Note 6*: This is the case for Windows-based and many POSIX-based
-operating systems. — *end note*]
-For a string in a Unicode encoding, implementations should estimate the
-width of a string as the sum of estimated widths of the first code
-points in its extended grapheme clusters. The extended grapheme clusters
-of a string are defined by UAX \#29. The estimated width of the
-following code points is 2:
-- `U+1100-U+115F`
-- `U+2329-U+232A`
-- `U+2E80-U+303E`
-- `U+3040-U+A4CF`
-- `U+AC00-U+D7A3`
-- `U+F900-U+FAFF`
-- `U+FE10-U+FE19`
-- `U+FE30-U+FE6F`
-- `U+FF00-U+FF60`
-- `U+FFE0-U+FFE6`
-- `U+1F300-U+1F64F`
-- `U+1F900-U+1F9FF`
-- `U+20000-U+2FFFD`
-- `U+30000-U+3FFFD`
-The estimated width of other code points is 1.
-For a string in a non-Unicode encoding, the width of a string is
-unspecified.
-A zero (`0`) character preceding the *width* field pads the field with
-leading zeros (following any indication of sign or base) to the field
-width, except when applied to an infinity or NaN. This option is only
-valid for arithmetic types other than `charT` and `bool` or when an
-integer presentation type is specified. If the `0` character and an
-*align* option both appear, the `0` character is ignored.
 [*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 is ignored because of < alignment)
 ```
 — *end example*]
-The *nonnegative-integer* in *precision* is a decimal integer defining
-the precision or maximum field size. It can only be used with
-floating-point and string types. For floating-point types this field
-specifies the formatting precision. For string types, this field
-provides an upper bound for the estimated width of the prefix of the
-input string that is copied into the output. For a string in a Unicode
-encoding, the formatter copies to the output the longest prefix of whole
-extended grapheme clusters whose estimated width is no greater than the
-precision.
 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.
@@ -455,22 +532,23 @@ 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.                                   |
 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 7*: 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]].
@@ -479,49 +557,61 @@ The available integer presentation types for integral types other than
 ``` 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 might be "1,234"
                                                         // (depending on the locale)
 ```
 — *end example*]
-[*Note 8*: If the formatting argument type is `charT` or `bool`, the
-default is instead `c` or `s`, respectively. — *end note*]
 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]].                                  |
 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`, `c`, `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 9*: 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                                                                                                                                                                                                                                                                                                   |
@@ -537,77 +627,107 @@ respectively.
 The available pointer presentation types and their mapping to `to_chars`
 are specified in [[format.type.ptr]].
-[*Note 10*: 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` added to the output; 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]].
 ### 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(string_view fmt, const Args&... args);
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return vformat(fmt, make_format_args(args...));
 ```
 ``` cpp
 template<class... Args>
-  wstring format(wstring_view fmt, const Args&... args);
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return vformat(fmt, make_wformat_args(args...));
 ```
 ``` cpp
 template<class... Args>
-  string format(const locale& loc, string_view fmt, const Args&... args);
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return vformat(loc, fmt, make_format_args(args...));
 ```
 ``` cpp
 template<class... Args>
-  wstring format(const locale& loc, wstring_view fmt, const Args&... args);
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return vformat(loc, fmt, make_wformat_args(args...));
 ```
 ``` cpp
 string vformat(string_view fmt, format_args args);
 wstring vformat(wstring_view fmt, wformat_args args);
@@ -622,98 +742,108 @@ locale-specific formatting.
 *Throws:* As specified in  [[format.err.report]].
 ``` cpp
 template<class Out, class... Args>
-  Out format_to(Out out, string_view fmt, const Args&... args);
 template<class Out, class... Args>
-  Out format_to(Out out, wstring_view fmt, const Args&... args);
 ```
 *Effects:* Equivalent to:
 ``` cpp
-using context = basic_format_context<Out, decltype(fmt)::value_type>;
-return vformat_to(out, fmt, make_format_args<context>(args...));
 ```
 ``` cpp
 template<class Out, class... Args>
-  Out format_to(Out out, const locale& loc, string_view fmt, const Args&... args);
 template<class Out, class... Args>
-  Out format_to(Out out, const locale& loc, wstring_view fmt, const Args&... args);
 ```
 *Effects:* Equivalent to:
 ``` cpp
-using context = basic_format_context<Out, decltype(fmt)::value_type>;
-return vformat_to(out, loc, fmt, make_format_args<context>(args...));
 ```
 ``` cpp
 template<class Out>
-  Out vformat_to(Out out, string_view fmt,
-                 format_args_t<type_identity_t<Out>, char> args);
 template<class Out>
-  Out vformat_to(Out out, wstring_view fmt,
-                 format_args_t<type_identity_t<Out>, wchar_t> args);
 template<class Out>
-  Out vformat_to(Out out, const locale& loc, string_view fmt,
-                 format_args_t<type_identity_t<Out>, char> args);
 template<class Out>
-  Out vformat_to(Out out, const locale& loc, wstring_view fmt,
-                 format_args_t<type_identity_t<Out>, wchar_t> 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
-`formatted_size(fmt, args...)` for the functions without a `loc`
-parameter and `formatted_size(loc, fmt, args...)` for the functions with
-a `loc` parameter. 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,
- string_view fmt, const Args&... args);
 template<class Out, class... Args>
   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
- wstring_view fmt, const 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, string_view fmt,
- const 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, wstring_view fmt,
- const Args&... args);
 ```
 Let
-- `charT` be `decltype(fmt)::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<``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`,
@@ -723,22 +853,22 @@ according to the specifications given in `fmt`, into the range \[`out`,
 *Throws:* As specified in  [[format.err.report]].
 ``` cpp
 template<class... Args>
-  size_t formatted_size(string_view fmt, const Args&... args);
 template<class... Args>
-  size_t formatted_size(wstring_view fmt, const Args&... args);
 template<class... Args>
-  size_t formatted_size(const locale& loc, string_view fmt, const Args&... args);
 template<class... Args>
-  size_t formatted_size(const locale& loc, wstring_view fmt, const Args&... args);
 ```
-Let `charT` be `decltype(fmt)::value_type`.
-*Preconditions:* `formatter<``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.
@@ -747,27 +877,30 @@ in `fmt`. If present, `loc` is used for locale-specific formatting.
 ### 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]]), and
 - *Cpp17Destructible* ([[cpp17.destructible]])
- requirements,
-- it is swappable [[swappable.requirements]] for lvalues, 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]]:
-- `f` is a value 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
@@ -779,35 +912,70 @@ 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*]
 #### 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.
-[*Note 1*: Enabled specializations meet the requirements, and disabled
-specializations do not. — *end note*]
-Each header that declares the template `formatter` provides the
-following enabled specializations:
-- The specializations
   ``` cpp
   template<> struct formatter<char, char>;
   template<> struct formatter<char, wchar_t>;
   template<> struct formatter<wchar_t, wchar_t>;
   ```
-- For each `charT`, the string type specializations
   ``` cpp
   template<> struct formatter<charT*, charT>;
   template<> struct formatter<const charT*, charT>;
-  template<size_t N> struct formatter<const 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>;
   ```
@@ -826,21 +994,21 @@ following enabled specializations:
 The `parse` member functions of these formatters interpret the format
 specification as a *std-format-spec* as described in
 [[format.string.std]].
-[*Note 2*: 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 except as noted
-otherwise.
 If `F` is a disabled specialization of `formatter`, these values are
 `false`:
 - `is_default_constructible_v<F>`,
@@ -859,11 +1027,11 @@ An enabled specialization `formatter<T, charT>` meets the requirements
 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) {
     return formatter<const char*>::format(color_names[c], ctx);
   }
 };
 struct err {};
@@ -874,10 +1042,95 @@ std::string s2 = std::format("{}", red);        // OK, user-provided formatter
 std::string s3 = std::format("{}", err{});      // error: disabled formatter
 ```
 — *end example*]
 #### Class template `basic_format_parse_context` <a id="format.parse.ctx">[[format.parse.ctx]]</a>
 ``` cpp
 namespace std {
   template<class charT>
@@ -946,37 +1199,41 @@ constexpr void advance_to(const_iterator it);
 ``` cpp
 constexpr size_t next_arg_id();
 ```
-*Effects:* If `indexing_ != manual`, equivalent to:
 ``` cpp
 if (indexing_ == unknown)
   indexing_ = automatic;
 return next_arg_id_++;
 ```
-*Throws:* `format_error` if `indexing_ == manual` which indicates mixing
-of automatic and manual argument indexing.
 ``` cpp
 constexpr void check_arg_id(size_t id);
 ```
-*Effects:* If `indexing_ != automatic`, equivalent to:
 ``` cpp
 if (indexing_ == unknown)
   indexing_ = manual;
 ```
-*Throws:* `format_error` if `indexing_ == automatic` which indicates
-mixing of automatic and manual argument indexing.
-*Remarks:* Call expressions where `id >= num_args_` are not core
-constant expressions [[expr.const]].
 #### Class template `basic_format_context` <a id="format.context">[[format.context]]</a>
 ``` cpp
 namespace std {
@@ -988,11 +1245,11 @@ namespace std {
   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;
     std::locale locale();
     iterator out();
     void advance_to(iterator it);
   };
@@ -1008,19 +1265,18 @@ of the formatting arguments and the output iterator.
 `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`.
-[*Note 1*: For a given type `charT`, implementations are encouraged to
 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. — *end note*]
 ``` cpp
-basic_format_arg<basic_format_context> arg(size_t id) const;
 ```
 *Returns:* `args_.get(id)`.
 ``` cpp
@@ -1032,17 +1288,17 @@ takes one, and `std::locale()` otherwise.
 ``` cpp
 iterator out();
 ```
-*Returns:* `out_`.
 ``` cpp
 void advance_to(iterator it);
 ```
-*Effects:* Equivalent to: `out_ = it;`
 [*Example 1*:
 ``` cpp
 struct S { int value; };
@@ -1064,11 +1320,11 @@ template<> struct std::formatter<S> {
     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) {
     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");
@@ -1082,10 +1338,425 @@ template<> struct std::formatter<S> {
 std::string s = std::format("{0:{1}}", S{42}, 10);  // value of s is "xxxxxxxx42"
 ```
 — *end example*]
 ### Arguments <a id="format.arguments">[[format.arguments]]</a>
 #### Class template `basic_format_arg` <a id="format.arg">[[format.arg]]</a>
 ``` cpp
@@ -1102,28 +1773,11 @@ namespace std {
             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(const T& v) noexcept; // exposition only
-    explicit basic_format_arg(float n) noexcept;                                // exposition only
-    explicit basic_format_arg(double n) noexcept;                               // exposition only
-    explicit basic_format_arg(long double n) noexcept;                          // exposition only
-    explicit basic_format_arg(const char_type* s);                              // exposition only
-    template<class traits>
-      explicit basic_format_arg(
-        basic_string_view<char_type, traits> s) noexcept;                       // exposition only
-    template<class traits, class Allocator>
-      explicit basic_format_arg(
-        const basic_string<char_type, traits, Allocator>& s) noexcept;          // exposition only
-    explicit basic_format_arg(nullptr_t) noexcept;                              // exposition only
-    template<class T>
-      explicit basic_format_arg(const T* p) noexcept;                           // exposition only
   public:
     basic_format_arg() noexcept;
     explicit operator bool() const noexcept;
@@ -1142,95 +1796,47 @@ basic_format_arg() noexcept;
 ```
 *Ensures:* `!(*this)`.
 ``` cpp
-template<class T> explicit basic_format_arg(const T& v) noexcept;
 ```
-*Constraints:* The template specialization
-``` cpp
-typename Context::template formatter_type<T>
-```
-meets the requirements [[formatter.requirements]]. The extent to which
-an implementation determines that the specialization meets the
-requirements is unspecified, except that as a minimum the expression
-``` cpp
-typename Context::template formatter_type<T>()
-  .format(declval<const T&>(), declval<Context&>())
-```
-shall be well-formed when treated as an unevaluated operand.
-*Effects:*
-- if `T` is `bool` or `char_type`, initializes `value` with `v`;
-- otherwise, if `T` is `char` and `char_type` is `wchar_t`, initializes
   `value` with `static_cast<wchar_t>(v)`;
-- otherwise, if `T` is a signed integer type [[basic.fundamental]] and
-  `sizeof(T) <= sizeof(int)`, initializes `value` with
   `static_cast<int>(v)`;
-- otherwise, if `T` is an unsigned integer type and
-  `sizeof(T) <= sizeof(unsigned int)`, initializes `value` with
   `static_cast<unsigned int>(v)`;
-- otherwise, if `T` is a signed integer type and
-  `sizeof(T) <= sizeof(long long int)`, initializes `value` with
   `static_cast<long long int>(v)`;
-- otherwise, if `T` is an unsigned integer type and
-  `sizeof(T) <= sizeof(unsigned long long int)`, initializes `value`
   with `static_cast<unsigned long long int>(v)`;
 - otherwise, initializes `value` with `handle(v)`.
-``` cpp
-explicit basic_format_arg(float n) noexcept;
-explicit basic_format_arg(double n) noexcept;
-explicit basic_format_arg(long double n) noexcept;
-```
-*Effects:* Initializes `value` with `n`.
-``` cpp
-explicit basic_format_arg(const char_type* s);
-```
-*Preconditions:* `s` points to a NTCTS [[defns.ntcts]].
-*Effects:* Initializes `value` with `s`.
-``` cpp
-template<class traits>
-  explicit basic_format_arg(basic_string_view<char_type, traits> s) noexcept;
-```
-*Effects:* Initializes `value` with `s`.
-``` cpp
-template<class traits, class Allocator>
-  explicit basic_format_arg(
-    const basic_string<char_type, traits, Allocator>& s) noexcept;
-```
-*Effects:* Initializes `value` with
-`basic_string_view<char_type>(s.data(), s.size())`.
-``` cpp
-explicit basic_format_arg(nullptr_t) noexcept;
-```
-*Effects:* Initializes `value` with `static_cast<const void*>(nullptr)`.
-``` cpp
-template<class T> explicit basic_format_arg(const T* p) noexcept;
-```
-*Constraints:* `is_void_v<T>` is `true`.
-*Effects:* Initializes `value` with `p`.
 [*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
@@ -1247,32 +1853,41 @@ namespace std {
   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(const 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(const T& val) noexcept;
 ```
 *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<T> f;
   parse_ctx.advance_to(f.parse(parse_ctx));
-  format_ctx.advance_to(f.format(*static_cast<const T*>(ptr), format_ctx));
 }
 ```
 ``` cpp
 void format(basic_format_parse_context<char_type>& parse_ctx, Context& format_ctx) const;
@@ -1280,43 +1895,46 @@ void format(basic_format_parse_context<char_type>& parse_ctx, Context& format_ct
 *Effects:* Equivalent to: `format_(parse_ctx, format_ctx, ptr_);`
 ``` cpp
 template<class Visitor, class Context>
- see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
 ```
 *Effects:* Equivalent to:
-`return visit(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>
- struct format-arg-store { // exposition only
-    array<basic_format_arg<Context>, sizeof...(Args)> 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(const Args&... args);
 ```
 *Preconditions:* The type
-`typename Context::template formatter_type<``Tᵢ``>` meets the
-requirements [[formatter.requirements]] for each `Tᵢ` in `Args`.
-*Returns:* `{basic_format_arg<Context>(args)...}`.
 ``` cpp
 template<class... Args>
-  format-arg-store<wformat_context, Args...> make_wformat_args(const Args&... args);
 ```
 *Effects:* Equivalent to:
 `return make_format_args<wformat_context>(args...);`
@@ -1335,15 +1953,22 @@ namespace std {
     template<class... Args>
       basic_format_args(const format-arg-store<Context, Args...>& store) noexcept;
     basic_format_arg<Context> get(size_t i) const noexcept;
   };
 }
 ```
 An instance of `basic_format_args` provides access to formatting
-arguments.
 ``` cpp
 basic_format_args() noexcept;
 ```
@@ -1361,14 +1986,140 @@ template<class... Args>
 basic_format_arg<Context> get(size_t i) const noexcept;
 ```
 *Returns:* `i < size_ ? data_[i] : basic_format_arg<Context>()`.
-[*Note 1*: Implementations are encouraged to optimize the
-representation of `basic_format_args` for small number of formatting
-arguments by storing indices of type alternatives separately from values
-and packing the former. — *end note*]
 ### Class `format_error` <a id="format.error">[[format.error]]</a>
 ``` cpp
 namespace std {
@@ -1393,406 +2144,5 @@ format_error(const string& what_arg);
 format_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
-<!-- Link reference definitions -->
-[alg.sorting]: algorithms.md#alg.sorting
-[algorithms]: algorithms.md#algorithms
-[algorithms.general]: algorithms.md#algorithms.general
-[algorithms.requirements]: algorithms.md#algorithms.requirements
-[allocator.adaptor]: #allocator.adaptor
-[allocator.adaptor.cnstr]: #allocator.adaptor.cnstr
-[allocator.adaptor.members]: #allocator.adaptor.members
-[allocator.adaptor.syn]: #allocator.adaptor.syn
-[allocator.adaptor.types]: #allocator.adaptor.types
-[allocator.globals]: #allocator.globals
-[allocator.members]: #allocator.members
-[allocator.requirements.completeness]: library.md#allocator.requirements.completeness
-[allocator.tag]: #allocator.tag
-[allocator.traits]: #allocator.traits
-[allocator.traits.members]: #allocator.traits.members
-[allocator.traits.types]: #allocator.traits.types
-[allocator.uses]: #allocator.uses
-[allocator.uses.construction]: #allocator.uses.construction
-[allocator.uses.trait]: #allocator.uses.trait
-[any]: #any
-[any.assign]: #any.assign
-[any.bad.any.cast]: #any.bad.any.cast
-[any.class]: #any.class
-[any.cons]: #any.cons
-[any.modifiers]: #any.modifiers
-[any.nonmembers]: #any.nonmembers
-[any.observers]: #any.observers
-[any.synop]: #any.synop
-[arithmetic.operations]: #arithmetic.operations
-[arithmetic.operations.divides]: #arithmetic.operations.divides
-[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
-[array]: containers.md#array
-[associative]: containers.md#associative
-[basic.align]: basic.md#basic.align
-[basic.compound]: basic.md#basic.compound
-[basic.def.odr]: basic.md#basic.def.odr
-[basic.fundamental]: basic.md#basic.fundamental
-[basic.life]: basic.md#basic.life
-[basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
-[basic.stc.dynamic.safety]: basic.md#basic.stc.dynamic.safety
-[basic.types]: basic.md#basic.types
-[bitmask.types]: library.md#bitmask.types
-[bitset]: #bitset
-[bitset.cons]: #bitset.cons
-[bitset.hash]: #bitset.hash
-[bitset.members]: #bitset.members
-[bitset.operators]: #bitset.operators
-[bitset.syn]: #bitset.syn
-[bitwise.operations]: #bitwise.operations
-[bitwise.operations.and]: #bitwise.operations.and
-[bitwise.operations.not]: #bitwise.operations.not
-[bitwise.operations.or]: #bitwise.operations.or
-[bitwise.operations.xor]: #bitwise.operations.xor
-[c.malloc]: #c.malloc
-[charconv]: #charconv
-[charconv.from.chars]: #charconv.from.chars
-[charconv.syn]: #charconv.syn
-[charconv.to.chars]: #charconv.to.chars
-[class.copy.ctor]: class.md#class.copy.ctor
-[class.mem]: class.md#class.mem
-[comparisons]: #comparisons
-[comparisons.equal.to]: #comparisons.equal.to
-[comparisons.greater]: #comparisons.greater
-[comparisons.greater.equal]: #comparisons.greater.equal
-[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
-[conv.array]: expr.md#conv.array
-[conv.func]: expr.md#conv.func
-[conv.lval]: expr.md#conv.lval
-[conv.qual]: expr.md#conv.qual
-[conv.rank]: basic.md#conv.rank
-[cpp17.allocator]: #cpp17.allocator
-[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
-[cpp17.nullablepointer]: #cpp17.nullablepointer
-[dcl.array]: dcl.md#dcl.array
-[dcl.constexpr]: dcl.md#dcl.constexpr
-[dcl.ref]: dcl.md#dcl.ref
-[declval]: #declval
-[default.allocator]: #default.allocator
-[defns.const.subexpr]: library.md#defns.const.subexpr
-[defns.expression-equivalent]: library.md#defns.expression-equivalent
-[defns.ntcts]: library.md#defns.ntcts
-[defns.order.ptr]: #defns.order.ptr
-[defns.referenceable]: library.md#defns.referenceable
-[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
-[expr.add]: expr.md#expr.add
-[expr.alignof]: expr.md#expr.alignof
-[expr.bit.and]: expr.md#expr.bit.and
-[expr.call]: expr.md#expr.call
-[expr.const]: expr.md#expr.const
-[expr.eq]: expr.md#expr.eq
-[expr.log.and]: expr.md#expr.log.and
-[expr.log.or]: expr.md#expr.log.or
-[expr.mul]: expr.md#expr.mul
-[expr.or]: expr.md#expr.or
-[expr.prop]: expr.md#expr.prop
-[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.formatter]: #format.formatter
-[format.formatter.spec]: #format.formatter.spec
-[format.functions]: #format.functions
-[format.parse.ctx]: #format.parse.ctx
-[format.sign]: #format.sign
-[format.string]: #format.string
-[format.string.general]: #format.string.general
-[format.string.std]: #format.string.std
-[format.syn]: #format.syn
-[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.requirements]: #formatter.requirements
-[forward]: #forward
-[func.bind]: #func.bind
-[func.bind.bind]: #func.bind.bind
-[func.bind.front]: #func.bind.front
-[func.bind.isbind]: #func.bind.isbind
-[func.bind.isplace]: #func.bind.isplace
-[func.bind.place]: #func.bind.place
-[func.def]: #func.def
-[func.identity]: #func.identity
-[func.invoke]: #func.invoke
-[func.memfn]: #func.memfn
-[func.not.fn]: #func.not.fn
-[func.require]: #func.require
-[func.search]: #func.search
-[func.search.bm]: #func.search.bm
-[func.search.bmh]: #func.search.bmh
-[func.search.default]: #func.search.default
-[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.inv]: #func.wrap.func.inv
-[func.wrap.func.mod]: #func.wrap.func.mod
-[func.wrap.func.nullptr]: #func.wrap.func.nullptr
-[func.wrap.func.targ]: #func.wrap.func.targ
-[function.objects]: #function.objects
-[functional.syn]: #functional.syn
-[intro.multithread]: basic.md#intro.multithread
-[intro.object]: basic.md#intro.object
-[intseq]: #intseq
-[intseq.general]: #intseq.general
-[intseq.intseq]: #intseq.intseq
-[intseq.make]: #intseq.make
-[invalid.argument]: diagnostics.md#invalid.argument
-[iostate.flags]: input.md#iostate.flags
-[istream.formatted]: input.md#istream.formatted
-[logical.operations]: #logical.operations
-[logical.operations.and]: #logical.operations.and
-[logical.operations.not]: #logical.operations.not
-[logical.operations.or]: #logical.operations.or
-[mem.poly.allocator.class]: #mem.poly.allocator.class
-[mem.poly.allocator.ctor]: #mem.poly.allocator.ctor
-[mem.poly.allocator.eq]: #mem.poly.allocator.eq
-[mem.poly.allocator.mem]: #mem.poly.allocator.mem
-[mem.res]: #mem.res
-[mem.res.class]: #mem.res.class
-[mem.res.eq]: #mem.res.eq
-[mem.res.global]: #mem.res.global
-[mem.res.monotonic.buffer]: #mem.res.monotonic.buffer
-[mem.res.monotonic.buffer.ctor]: #mem.res.monotonic.buffer.ctor
-[mem.res.monotonic.buffer.mem]: #mem.res.monotonic.buffer.mem
-[mem.res.pool]: #mem.res.pool
-[mem.res.pool.ctor]: #mem.res.pool.ctor
-[mem.res.pool.mem]: #mem.res.pool.mem
-[mem.res.pool.options]: #mem.res.pool.options
-[mem.res.pool.overview]: #mem.res.pool.overview
-[mem.res.private]: #mem.res.private
-[mem.res.public]: #mem.res.public
-[mem.res.syn]: #mem.res.syn
-[memory]: #memory
-[memory.general]: #memory.general
-[memory.syn]: #memory.syn
-[meta]: #meta
-[meta.const.eval]: #meta.const.eval
-[meta.help]: #meta.help
-[meta.logical]: #meta.logical
-[meta.member]: #meta.member
-[meta.rel]: #meta.rel
-[meta.rqmts]: #meta.rqmts
-[meta.trans]: #meta.trans
-[meta.trans.arr]: #meta.trans.arr
-[meta.trans.cv]: #meta.trans.cv
-[meta.trans.other]: #meta.trans.other
-[meta.trans.ptr]: #meta.trans.ptr
-[meta.trans.ref]: #meta.trans.ref
-[meta.trans.sign]: #meta.trans.sign
-[meta.type.synop]: #meta.type.synop
-[meta.unary]: #meta.unary
-[meta.unary.cat]: #meta.unary.cat
-[meta.unary.comp]: #meta.unary.comp
-[meta.unary.prop]: #meta.unary.prop
-[meta.unary.prop.query]: #meta.unary.prop.query
-[namespace.std]: library.md#namespace.std
-[new.delete]: support.md#new.delete
-[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.assign.move.templ]: #optional.assign.move.templ
-[optional.bad.access]: #optional.bad.access
-[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.nullops]: #optional.nullops
-[optional.nullopt]: #optional.nullopt
-[optional.observe]: #optional.observe
-[optional.optional]: #optional.optional
-[optional.relops]: #optional.relops
-[optional.specalg]: #optional.specalg
-[optional.swap]: #optional.swap
-[optional.syn]: #optional.syn
-[ostream.formatted]: input.md#ostream.formatted
-[out.of.range]: diagnostics.md#out.of.range
-[over.match.call]: over.md#over.match.call
-[over.match.class.deduct]: over.md#over.match.class.deduct
-[overflow.error]: diagnostics.md#overflow.error
-[pair.astuple]: #pair.astuple
-[pair.piecewise]: #pair.piecewise
-[pairs]: #pairs
-[pairs.general]: #pairs.general
-[pairs.pair]: #pairs.pair
-[pairs.spec]: #pairs.spec
-[pointer.conversion]: #pointer.conversion
-[pointer.traits]: #pointer.traits
-[pointer.traits.functions]: #pointer.traits.functions
-[pointer.traits.optmem]: #pointer.traits.optmem
-[pointer.traits.types]: #pointer.traits.types
-[ptr.align]: #ptr.align
-[range.cmp]: #range.cmp
-[ratio]: #ratio
-[ratio.arithmetic]: #ratio.arithmetic
-[ratio.comparison]: #ratio.comparison
-[ratio.general]: #ratio.general
-[ratio.ratio]: #ratio.ratio
-[ratio.si]: #ratio.si
-[ratio.syn]: #ratio.syn
-[refwrap]: #refwrap
-[refwrap.access]: #refwrap.access
-[refwrap.assign]: #refwrap.assign
-[refwrap.const]: #refwrap.const
-[refwrap.helpers]: #refwrap.helpers
-[refwrap.invoke]: #refwrap.invoke
-[res.on.exception.handling]: library.md#res.on.exception.handling
-[round.style]: support.md#round.style
-[scoped.adaptor.operators]: #scoped.adaptor.operators
-[smartptr]: #smartptr
-[special]: class.md#special
-[specialized.addressof]: #specialized.addressof
-[specialized.algorithms]: algorithms.md#specialized.algorithms
-[stmt.dcl]: stmt.md#stmt.dcl
-[stmt.return]: stmt.md#stmt.return
-[support.signal]: support.md#support.signal
-[swappable.requirements]: library.md#swappable.requirements
-[temp.deduct]: temp.md#temp.deduct
-[temp.param]: temp.md#temp.param
-[temp.type]: temp.md#temp.type
-[template.bitset]: #template.bitset
-[time.format]: time.md#time.format
-[tuple]: #tuple
-[tuple.apply]: #tuple.apply
-[tuple.assign]: #tuple.assign
-[tuple.cnstr]: #tuple.cnstr
-[tuple.creation]: #tuple.creation
-[tuple.elem]: #tuple.elem
-[tuple.general]: #tuple.general
-[tuple.helper]: #tuple.helper
-[tuple.rel]: #tuple.rel
-[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
-[unique.ptr]: #unique.ptr
-[unique.ptr.create]: #unique.ptr.create
-[unique.ptr.dltr]: #unique.ptr.dltr
-[unique.ptr.dltr.dflt]: #unique.ptr.dltr.dflt
-[unique.ptr.dltr.dflt1]: #unique.ptr.dltr.dflt1
-[unique.ptr.dltr.general]: #unique.ptr.dltr.general
-[unique.ptr.io]: #unique.ptr.io
-[unique.ptr.runtime]: #unique.ptr.runtime
-[unique.ptr.runtime.asgn]: #unique.ptr.runtime.asgn
-[unique.ptr.runtime.ctor]: #unique.ptr.runtime.ctor
-[unique.ptr.runtime.modifiers]: #unique.ptr.runtime.modifiers
-[unique.ptr.runtime.observers]: #unique.ptr.runtime.observers
-[unique.ptr.single]: #unique.ptr.single
-[unique.ptr.single.asgn]: #unique.ptr.single.asgn
-[unique.ptr.single.ctor]: #unique.ptr.single.ctor
-[unique.ptr.single.dtor]: #unique.ptr.single.dtor
-[unique.ptr.single.modifiers]: #unique.ptr.single.modifiers
-[unique.ptr.single.observers]: #unique.ptr.single.observers
-[unique.ptr.special]: #unique.ptr.special
-[unord]: containers.md#unord
-[unord.hash]: #unord.hash
-[util.dynamic.safety]: #util.dynamic.safety
-[util.smartptr.enab]: #util.smartptr.enab
-[util.smartptr.getdeleter]: #util.smartptr.getdeleter
-[util.smartptr.hash]: #util.smartptr.hash
-[util.smartptr.ownerless]: #util.smartptr.ownerless
-[util.smartptr.shared]: #util.smartptr.shared
-[util.smartptr.shared.assign]: #util.smartptr.shared.assign
-[util.smartptr.shared.cast]: #util.smartptr.shared.cast
-[util.smartptr.shared.cmp]: #util.smartptr.shared.cmp
-[util.smartptr.shared.const]: #util.smartptr.shared.const
-[util.smartptr.shared.create]: #util.smartptr.shared.create
-[util.smartptr.shared.dest]: #util.smartptr.shared.dest
-[util.smartptr.shared.io]: #util.smartptr.shared.io
-[util.smartptr.shared.mod]: #util.smartptr.shared.mod
-[util.smartptr.shared.obs]: #util.smartptr.shared.obs
-[util.smartptr.shared.spec]: #util.smartptr.shared.spec
-[util.smartptr.weak]: #util.smartptr.weak
-[util.smartptr.weak.assign]: #util.smartptr.weak.assign
-[util.smartptr.weak.bad]: #util.smartptr.weak.bad
-[util.smartptr.weak.const]: #util.smartptr.weak.const
-[util.smartptr.weak.dest]: #util.smartptr.weak.dest
-[util.smartptr.weak.mod]: #util.smartptr.weak.mod
-[util.smartptr.weak.obs]: #util.smartptr.weak.obs
-[util.smartptr.weak.spec]: #util.smartptr.weak.spec
-[utilities]: #utilities
-[utilities.general]: #utilities.general
-[utilities.summary]: #utilities.summary
-[utility]: #utility
-[utility.as.const]: #utility.as.const
-[utility.exchange]: #utility.exchange
-[utility.intcmp]: #utility.intcmp
-[utility.swap]: #utility.swap
-[utility.syn]: #utility.syn
-[variant]: #variant
-[variant.assign]: #variant.assign
-[variant.bad.access]: #variant.bad.access
-[variant.ctor]: #variant.ctor
-[variant.dtor]: #variant.dtor
-[variant.general]: #variant.general
-[variant.get]: #variant.get
-[variant.hash]: #variant.hash
-[variant.helper]: #variant.helper
-[variant.mod]: #variant.mod
-[variant.monostate]: #variant.monostate
-[variant.monostate.relops]: #variant.monostate.relops
-[variant.relops]: #variant.relops
-[variant.specalg]: #variant.specalg
-[variant.status]: #variant.status
-[variant.swap]: #variant.swap
-[variant.syn]: #variant.syn
-[variant.variant]: #variant.variant
-[variant.visit]: #variant.visit
-[^1]: `pointer_safety::preferred` might be returned to indicate that a
-    leak detector is running so that the program can avoid spurious leak
-    reports.
-[^2]: 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.

 ### 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;
 }
 ```
 ``` 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
 — *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
     '.' '{' 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
 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*:
 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.
 [[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]].
 ``` 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                                                                                                                                                                                                                                                                                                   |
 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);
 *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`,
 *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.
 ### 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
 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>;
   ```
 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>`,
 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 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>
 ``` 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 {
   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);
   };
 `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
 ``` 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; };
     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");
 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
             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;
 ```
 *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
   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...);`
     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;
 ```
 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 {
 format_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.

Diff to HTML by rtfpessoa