[locale.categories] - C++14 → C++17

Files changed (1) hide show

tmp/tmp0qang188/{from.md → to.md} +362 -346

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

@@ -23,11 +23,11 @@ another virtual function.
 ``` cpp
 namespace std {
   class ctype_base {
   public:
- typedef T mask;
     // numeric values are for exposition only.
     static const mask space = 1 << 0;
     static const mask print = 1 << 1;
     static const mask cntrl = 1 << 2;
@@ -51,49 +51,42 @@ The type `mask` is a bitmask type ([[bitmask.types]]).
 ``` cpp
 namespace std {
   template <class charT>
     class ctype : public locale::facet, public ctype_base {
     public:
-    typedef charT char_type;
       explicit ctype(size_t refs = 0);
       bool         is(mask m, charT c) const;
       const charT* is(const charT* low, const charT* high, mask* vec) const;
- const charT* scan_is(mask m,
- const charT* low, const charT* high) const;
-    const charT* scan_not(mask m,
-                          const charT* low, const charT* high) const;
       charT        toupper(charT c) const;
       const charT* toupper(charT* low, const charT* high) const;
       charT        tolower(charT c) const;
       const charT* tolower(charT* low, const charT* high) const;
       charT        widen(char c) const;
       const char*  widen(const char* low, const char* high, charT* to) const;
       char         narrow(charT c, char dfault) const;
- const charT* narrow(const charT* low, const charT*, char dfault,
-                        char* to) const;
       static locale::id id;
     protected:
       ~ctype();
       virtual bool         do_is(mask m, charT c) const;
- virtual const charT* do_is(const charT* low, const charT* high,
- mask* vec) const;
- virtual const charT* do_scan_is(mask m,
-                                    const charT* low, const charT* high) const;
-    virtual const charT* do_scan_not(mask m,
-                                     const charT* low, const charT* high) const;
       virtual charT        do_toupper(charT) const;
       virtual const charT* do_toupper(charT* low, const charT* high) const;
       virtual charT        do_tolower(charT) const;
       virtual const charT* do_tolower(charT* low, const charT* high) const;
       virtual charT        do_widen(char) const;
- virtual const char*  do_widen(const char* low, const char* high,
-                                  charT* dest) const;
       virtual char         do_narrow(charT, char dfault) const;
       virtual const charT* do_narrow(const charT* low, const charT* high,
                                      char dfault, char* dest) const;
     };
 }
@@ -114,54 +107,54 @@ appropriate to the implementation’s native character set.
 bool         is(mask m, charT c) const;
 const charT* is(const charT* low, const charT* high,
                 mask* vec) const;
 ```
-*Returns:* `do_is(m,c)` or `do_is(low,high,vec)`
 ``` cpp
 const charT* scan_is(mask m,
                      const charT* low, const charT* high) const;
 ```
-*Returns:* `do_scan_is(m,low,high)`
 ``` cpp
 const charT* scan_not(mask m,
                       const charT* low, const charT* high) const;
 ```
-*Returns:* `do_scan_not(m,low,high)`
 ``` cpp
 charT        toupper(charT) const;
 const charT* toupper(charT* low, const charT* high) const;
 ```
-*Returns:* `do_toupper(c)` or `do_toupper(low,high)`
 ``` cpp
 charT        tolower(charT c) const;
 const charT* tolower(charT* low, const charT* high) const;
 ```
-*Returns:* `do_tolower(c)` or `do_tolower(low,high)`
 ``` cpp
 charT       widen(char c) const;
 const char* widen(const char* low, const char* high, charT* to) const;
 ```
-*Returns:* `do_widen(c)` or `do_widen(low,high,to)`
 ``` cpp
 char         narrow(charT c, char dfault) const;
-const charT* narrow(const charT* low, const charT*, char dfault,
                     char* to) const;
 ```
-*Returns:* `do_narrow(c,dfault)` or `do_narrow(low,high,dfault,to)`
 ##### `ctype` virtual functions <a id="locale.ctype.virtuals">[[locale.ctype.virtuals]]</a>
 ``` cpp
 bool         do_is(mask m, charT c) const;
@@ -170,30 +163,29 @@ const charT* do_is(const charT* low, const charT* high,
 ```
 *Effects:* Classifies a character or sequence of characters. For each
 argument character, identifies a value `M` of type `ctype_base::mask`.
 The second form identifies a value `M` of type `ctype_base::mask` for
-each `*p` where `(low<=p && p<high)`, and places it into `vec[p-low]`.
 *Returns:* The first form returns the result of the expression
 `(M & m) != 0`; i.e., `true` if the character has the characteristics
 specified. The second form returns `high`.
 ``` cpp
-const charT* do_scan_is(mask m,
-                       const charT* low, const charT* high) const;
 ```
 *Effects:* Locates a character in a buffer that conforms to a
 classification `m`.
-*Returns:* The smallest pointer `p` in the range `[low, high)` such that
-`is(m,*p)` would return `true`; otherwise, returns `high`.
 ``` cpp
-const charT* do_scan_not(mask m,
-                        const charT* low, const charT* high) const;
 ```
 *Effects:* Locates a character in a buffer that fails to conform to a
 classification `m`.
@@ -233,16 +225,16 @@ const char*  do_widen(const char* low, const char* high,
                       charT* dest) const;
 ```
 *Effects:* Applies the simplest reasonable transformation from a `char`
 value or sequence of `char` values to the corresponding `charT` value or
-values.[^4] The only characters for which unique transformations are
 required are those in the basic source character set ([[lex.charset]]).
 For any named `ctype` category with a `ctype <charT>` facet `ctc` and
 valid `ctype_base::mask` value `M`,
-`(ctc.is(M, c) || !is(M, do_widen(c)) )` is `true`.[^5]
 The second form transforms each character `*p` in the range \[`low`,
 `high`), placing the result in `dest[p - low]`.
 *Returns:* The first form returns the transformed value. The second form
@@ -287,11 +279,11 @@ no mapping is readily available. The second form returns `high`.
 ``` cpp
 namespace std {
   template <class charT>
     class ctype_byname : public ctype<charT> {
     public:
-    typedef typename ctype<charT>::mask mask;
       explicit ctype_byname(const char*, size_t refs = 0);
       explicit ctype_byname(const string&, size_t refs = 0);
     protected:
       ~ctype_byname();
     };
@@ -300,14 +292,14 @@ namespace std {
 #### `ctype` specializations <a id="facet.ctype.special">[[facet.ctype.special]]</a>
 ``` cpp
 namespace std {
-  template <> class ctype<char>
-    : public locale::facet, public ctype_base {
     public:
-    typedef char char_type;
       explicit ctype(const mask* tab = 0, bool del = false,
                      size_t refs = 0);
       bool is(mask m, char c) const;
@@ -352,21 +344,21 @@ namespace std {
     };
 }
 ```
 A specialization `ctype<char>` is provided so that the member functions
-on type `char` can be implemented `inline`.[^6] The
 *implementation-defined* value of member `table_size` is at least 256.
 ##### `ctype<char>` destructor <a id="facet.ctype.char.dtor">[[facet.ctype.char.dtor]]</a>
 ``` cpp
 ~ctype();
 ```
 *Effects:* If the constructor’s first argument was nonzero, and its
-second argument was true, does `delete [] table()`.
 ##### `ctype<char>` members <a id="facet.ctype.char.members">[[facet.ctype.char.members]]</a>
 In the following member descriptions, for `unsigned char` values `v`
 where `v >= table_size`, `table()[v]` is assumed to have an
@@ -376,22 +368,23 @@ implementation-specific value (possibly different for each such value
 ``` cpp
 explicit ctype(const mask* tbl = 0, bool del = false,
                size_t refs = 0);
 ```
-`tbl` either 0 or an array of at least `table_size` elements.
 *Effects:* Passes its `refs` argument to its base class constructor.
 ``` cpp
 bool        is(mask m, char c) const;
 const char* is(const char* low, const char* high,
                mask* vec) const;
 ```
 *Effects:* The second form, for all `*p` in the range \[`low`, `high`),
-assigns into `vec[p-low]` the value `table()[ (unsigned char)*p]`.
 *Returns:* The first form returns `table()[(unsigned char)c] & m`; the
 second form returns `high`.
 ``` cpp
@@ -453,22 +446,22 @@ respectively.
 ``` cpp
 const mask* table() const noexcept;
 ```
-*Returns:* The first constructor argument, if it was non-zero, otherwise
 `classic_table()`.
 ##### `ctype<char>` static members <a id="facet.ctype.char.statics">[[facet.ctype.char.statics]]</a>
 ``` cpp
 static const mask* classic_table() noexcept;
 ```
 *Returns:* A pointer to the initial element of an array of size
 `table_size` which represents the classifications of characters in the
-"C" locale.
 ##### `ctype<char>` virtual functions <a id="facet.ctype.char.virtuals">[[facet.ctype.char.virtuals]]</a>
 ``` cpp
 char        do_toupper(char) const;
@@ -499,46 +492,54 @@ namespace std {
   };
   template <class internT, class externT, class stateT>
     class codecvt : public locale::facet, public codecvt_base {
     public:
-    typedef internT  intern_type;
-    typedef externT  extern_type;
-    typedef stateT state_type;
       explicit codecvt(size_t refs = 0);
- result out(stateT& state,
           const internT* from, const internT* from_end, const internT*& from_next,
                 externT*   to,       externT*   to_end,       externT*&   to_next) const;
-    result unshift(stateT& state,
                 externT*    to,      externT*   to_end,       externT*&   to_next) const;
-    result in(stateT& state,
           const externT* from, const externT* from_end, const externT*& from_next,
                 internT*   to,       internT*   to_end,       internT*&   to_next) const;
       int encoding() const noexcept;
       bool always_noconv() const noexcept;
- int length(stateT&, const externT* from, const externT* end,
-               size_t max) const;
       int max_length() const noexcept;
       static locale::id id;
     protected:
       ~codecvt();
- virtual result do_out(stateT& state,
           const internT* from, const internT* from_end, const internT*& from_next,
                 externT* to,         externT*   to_end,       externT*&   to_next) const;
- virtual result do_in(stateT& state,
           const externT* from, const externT* from_end, const externT*& from_next,
                 internT* to,         internT*   to_end,       internT*&   to_next) const;
- virtual result do_unshift(stateT& state,
                 externT* to,         externT*   to_end,       externT*&   to_next) const;
       virtual int do_encoding() const noexcept;
       virtual bool do_always_noconv() const noexcept;
- virtual int do_length(stateT&, const externT* from,
-                          const externT* end, size_t max) const;
       virtual int do_max_length() const noexcept;
     };
 }
 ```
@@ -552,103 +553,105 @@ mapped between.
 The specializations required in Table
 [[tab:localization.category.facets]] ([[locale.category]]) convert the
 implementation-defined native character set.
 `codecvt<char, char, mbstate_t>` implements a degenerate conversion; it
-does not convert at all. The specialization `codecvt<char16_t,`
-`char, mbstate_t>` converts between the UTF-16 and UTF-8 encoding forms,
-and the specialization `codecvt` `<char32_t, char, mbstate_t>` converts
-between the UTF-32 and UTF-8 encoding forms.
-`codecvt<wchar_t,char,mbstate_t>` converts between the native character
-sets for narrow and wide characters. Specializations on `mbstate_t`
-perform conversion between encodings known to the library implementer.
-Other encodings can be converted by specializing on a user-defined
-`stateT` type. Objects of type `stateT` can contain any state that is
-useful to communicate to or from the specialized `do_in` or `do_out`
-members.
 ##### `codecvt` members <a id="locale.codecvt.members">[[locale.codecvt.members]]</a>
 ``` cpp
-result out(stateT& state,
     const internT* from, const internT* from_end, const internT*& from_next,
     externT* to, externT* to_end, externT*& to_next) const;
 ```
 *Returns:*
-`do_out(state, from, from_end, from_next, to, to_end, to_next)`
 ``` cpp
-result unshift(stateT& state,
-        externT* to, externT* to_end, externT*& to_next) const;
 ```
-*Returns:* `do_unshift(state, to, to_end, to_next)`
 ``` cpp
-result in(stateT& state,
     const externT* from, const externT* from_end, const externT*& from_next,
     internT* to, internT* to_end, internT*& to_next) const;
 ```
 *Returns:*
-`do_in(state, from, from_end, from_next, to, to_end, to_next)`
 ``` cpp
 int encoding() const noexcept;
 ```
-*Returns:* `do_encoding()`
 ``` cpp
 bool always_noconv() const noexcept;
 ```
-*Returns:* `do_always_noconv()`
 ``` cpp
-int length(stateT& state, const externT* from, const externT* from_end,
-           size_t max) const;
 ```
-*Returns:* `do_length(state, from,from_end,max)`
 ``` cpp
 int max_length() const noexcept;
 ```
-*Returns:* `do_max_length()`
 ##### `codecvt` virtual functions <a id="locale.codecvt.virtuals">[[locale.codecvt.virtuals]]</a>
 ``` cpp
-result do_out(stateT& state,
     const internT* from, const internT* from_end, const internT*& from_next,
     externT* to, externT* to_end, externT*& to_next) const;
-result do_in(stateT& state,
     const externT* from, const externT* from_end, const externT*& from_next,
     internT* to, internT* to_end, internT*& to_next) const;
 ```
-*Preconditions:* `(from<=from_end && to<=to_end)` well-defined and
 `true`; `state` initialized, if at the beginning of a sequence, or else
 equal to the result of converting the preceding characters in the
 sequence.
-*Effects:* Translates characters in the source range `[from,from_end)`,
-placing the results in sequential positions starting at destination
-`to`. Converts no more than `(from_end-from)` source elements, and
-stores no more than `(to_end-to)` destination elements.
 Stops if it encounters a character it cannot convert. It always leaves
 the `from_next` and `to_next` pointers pointing one beyond the last
 element successfully converted. If returns `noconv`, `internT` and
 `externT` are the same type and the converted sequence is identical to
-the input sequence `[from, from_next)`. `to_next` is set equal to `to`,
-the value of `state` is unchanged, and there are no changes to the
-values in `[to, to_end)`.
 A `codecvt` facet that is used by `basic_filebuf` ([[file.streams]])
 shall have the property that if
 ``` cpp
@@ -671,105 +674,107 @@ would return `ok`, where `to != to_end`, then
 ``` cpp
 do_in(state, from, from_end, from_next, to, to + 1, to_next)
 ```
-shall also return `ok`.[^7] As a result of operations on `state`, it can
-return `ok` or `partial` and set `from_next == from` and
-`to_next != to`.
-*Remarks:* Its operations on `state` are unspecified. This argument can
-be used, for example, to maintain shift state, to specify conversion
-options (such as count only), or to identify a cache of seek offsets.
 *Returns:* An enumeration value, as summarized in
 Table  [[tab:localization.convert.result.values.out.in]].
 **Table: `do_in/do_out` result values** <a id="tab:localization.convert.result.values.out.in">[tab:localization.convert.result.values.out.in]</a>
 | Value     | Meaning                                                                                          |
 | --------- | ------------------------------------------------------------------------------------------------ |
 | `ok`      | completed the conversion                                                                         |
 | `partial` | not all source characters converted                                                              |
-| `error`   | encountered a character in `[from,from_end)` that it could not convert |
 | `noconv`  | `internT` and `externT` are the same type, and input sequence is identical to converted sequence |
-A return value of `partial`, if `(from_next==from_end)`, indicates that
-either the destination sequence has not absorbed all the available
 destination elements, or that additional source elements are needed
 before another destination element can be produced.
 ``` cpp
-result do_unshift(stateT& state,
-  externT* to, externT* to_end, externT*& to_next) const;
 ```
-*Requires:* `(to <= to_end)` well defined and true; state initialized,
 if at the beginning of a sequence, or else equal to the result of
 converting the preceding characters in the sequence.
 *Effects:* Places characters starting at `to` that should be appended to
-terminate a sequence when the current `stateT` is given by `state`.[^8]
 Stores no more than `(to_end - to)` destination elements, and leaves the
 `to_next` pointer pointing one beyond the last element successfully
 stored.
 *Returns:* An enumeration value, as summarized in
 Table  [[tab:localization.convert.result.values.unshift]].
 **Table: `do_unshift` result values** <a id="tab:localization.convert.result.values.unshift">[tab:localization.convert.result.values.unshift]</a>
 | Value     | Meaning                                                                                                              |
-| --------- | ------------------------------------------------------------------------------------------------------------------ |
 | `ok`      | completed the sequence                                                                                               |
 | `partial` | space for more than `to_end - to` destination elements was needed to terminate a sequence given the value of `state` |
 | `error`   | an unspecified error has occurred                                                                                    |
 | `noconv`  | no termination is needed for this `state_type`                                                                       |
 ``` cpp
 int do_encoding() const noexcept;
 ```
-*Returns:* -1 if the encoding of the `externT` sequence is
 state-dependent; else the constant number of `externT` characters needed
-to produce an internal character; or 0 if this number is not a
-constant.[^9]
 ``` cpp
 bool do_always_noconv() const noexcept;
 ```
 *Returns:* `true` if `do_in()` and `do_out()` return `noconv` for all
 valid argument values. `codecvt<char, char, mbstate_t>` returns `true`.
 ``` cpp
-int do_length(stateT& state, const externT* from, const externT* from_end,
-              size_t max) const;
 ```
-*Preconditions:* `(from<=from_end)` well-defined and `true`; `state`
 initialized, if at the beginning of a sequence, or else equal to the
 result of converting the preceding characters in the sequence.
 *Effects:* The effect on the `state` argument is “as if” it called
 `do_in(state, from, from_end, from, to, to+max, to)` for `to` pointing
 to a buffer of at least `max` elements.
 *Returns:* `(from_next-from)` where `from_next` is the largest value in
-the range `[from,from_end]` such that the sequence of values in the
 range \[`from`, `from_next`) represents `max` or fewer valid complete
 characters of type `internT`. The specialization
 `codecvt<char, char, mbstate_t>`, returns the lesser of `max` and
 `(from_end-from)`.
 ``` cpp
 int do_max_length() const noexcept;
 ```
 *Returns:* The maximum value that `do_length(state, from, from_end, 1)`
-can return for any valid range `[from, from_end)` and `stateT` value
 `state`. The specialization
 `codecvt<char, char, mbstate_t>::do_max_length()` returns 1.
 #### Class template `codecvt_byname` <a id="locale.codecvt.byname">[[locale.codecvt.byname]]</a>
@@ -789,11 +794,11 @@ namespace std {
 ### The numeric category <a id="category.numeric">[[category.numeric]]</a>
 The classes `num_get<>` and `num_put<>` handle numeric formatting and
 parsing. Virtual functions are provided for several numeric types.
 Implementations may (but are not required to) delegate extraction of
-smaller types to extractors for larger types.[^10]
 All specifications of member functions for `num_put` and `num_get` in
 the subclauses of  [[category.numeric]] only apply to the
 specializations required in Tables  [[tab:localization.category.facets]]
 and  [[tab:localization.required.specializations]] (
@@ -814,12 +819,12 @@ values ([[istream.formatted.reqmts]], [[ostream.formatted.reqmts]]).
 ``` cpp
 namespace std {
   template <class charT, class InputIterator = istreambuf_iterator<charT>>
     class num_get : public locale::facet {
     public:
-    typedef charT            char_type;
-    typedef InputIterator    iter_type;
       explicit num_get(size_t refs = 0);
       iter_type get(iter_type in, iter_type end, ios_base&,
                     ios_base::iostate& err, bool& v) const;
@@ -991,12 +996,12 @@ as indicated in Table [[tab:localization.length.modifier.in]].
 | `double`             | `l`             |
 | `long double`        | `L`             |
 - **Stage 2:**
-If `in==end` then stage 2 terminates. Otherwise a `charT` is taken from
-`in` and local variables are initialized as if by
 ``` cpp
 char_type ct = *in;
 char c = src[find(atoms, atoms + sizeof(src) - 1, ct) - atoms];
 if (ct == use_facet<numpunct<charT>>(loc).decimal_point())
@@ -1014,11 +1019,11 @@ char_type atoms[sizeof(src)];
 use_facet<ctype<charT>>(loc).widen(src, src + sizeof(src), atoms);
 ```
 for this value of `loc`.
-If `discard` is true, then if `’.’` has not yet been accumulated, then
 the position of the character is remembered, but the character is
 otherwise ignored. Otherwise, if `’.’` has already been accumulated, the
 character is discarded and Stage 2 terminates. If it is not discarded,
 then a check is made to determine if `c` is allowed as the next
 character of an input field of the conversion specifier returned by
@@ -1035,54 +1040,60 @@ header `<cstdlib>`:
 - For a signed integer value, the function `strtoll`.
 - For an unsigned integer value, the function `strtoull`.
-- For a floating-point value, the function `strtold`.
 The numeric value to be stored can be one of:
-- zero, if the conversion function fails to convert the entire field.
-  `ios_base::failbit` is assigned to `err`.
-- the most positive representable value, if the field represents a value
- too large positive to be represented in `val`. `ios_base::failbit` is
- assigned to `err`.
-- the most negative representable value or zero for an unsigned integer
- type, if the field represents a value too large negative to be
- represented in `val`. `ios_base::failbit` is assigned to `err`.
 - the converted value, otherwise.
-The resultant numeric value is stored in `val`.
 Digit grouping is checked. That is, the positions of discarded
 separators is examined for consistency with
-`use_facet<numpunct<charT> >(loc).grouping()`. If they are not
-consistent then `ios_base::failbit` is assigned to `err`.
 In any case, if stage 2 processing was terminated by the test for
 `in == end` then `err |= ios_base::eofbit` is performed.
 ``` cpp
 iter_type do_get(iter_type in, iter_type end, ios_base& str,
                  ios_base::iostate& err, bool& val) const;
 ```
-*Effects:* If `(str``.flags()&ios_base::boolalpha)==0` then input
 proceeds as it would for a `long` except that if a value is being stored
 into `val`, the value is determined according to the following: If the
-value to be stored is 0 then `false` is stored. If the value is 1 then
 `true` is stored. Otherwise `true` is stored and `ios_base::failbit` is
 assigned to `err`.
 Otherwise target sequences are determined “as if” by calling the members
 `falsename()` and `truename()` of the facet obtained by
-`use_facet<numpunct<charT> >(str.getloc())`. Successive characters in
-the range \[`in`, `end`) (see  [[sequence.reqmts]]) are obtained and
-matched against corresponding positions in the target sequences only as
 necessary to identify a unique match. The input iterator `in` is
 compared to `end` only when necessary to obtain a character. If a target
 sequence is uniquely matched, `val` is set to the corresponding value.
 Otherwise `false` is stored and `ios_base::failbit` is assigned to
 `err`.
@@ -1090,127 +1101,102 @@ Otherwise `false` is stored and `ios_base::failbit` is assigned to
 The `in` iterator is always left pointing one position beyond the last
 character successfully matched. If `val` is set, then `err` is set to
 `str.goodbit`; or to `str.eofbit` if, when seeking another character to
 match, it is found that `(in == end)`. If `val` is not set, then `err`
 is set to `str.failbit`; or to `(str.failbit|str.eofbit)` if the reason
-for the failure was that `(in == end)`. For targets `true`: `"a"` and
-`false`: `"abb"`, the input sequence `"a"` yields `val == true` and
-`err == str.eofbit`; the input sequence `"abc"` yields
-`err = str.failbit`, with `in` ending at the `’c’` element. For targets
-`true`: `"1"` and `false`: `"0"`, the input sequence `"1"` yields
-`val == true` and `err == str.goodbit`. For empty targets `("")`, any
-input sequence yields `err == str.failbit`.
 *Returns:* `in`.
 #### Class template `num_put` <a id="locale.nm.put">[[locale.nm.put]]</a>
 ``` cpp
 namespace std {
   template <class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class num_put : public locale::facet {
     public:
-    typedef charT            char_type;
-    typedef OutputIterator   iter_type;
       explicit num_put(size_t refs = 0);
       iter_type put(iter_type s, ios_base& f, char_type fill, bool v) const;
       iter_type put(iter_type s, ios_base& f, char_type fill, long v) const;
       iter_type put(iter_type s, ios_base& f, char_type fill, long long v) const;
- iter_type put(iter_type s, ios_base& f, char_type fill,
- unsigned long v) const;
- iter_type put(iter_type s, ios_base& f, char_type fill,
-                  unsigned long long v) const;
- iter_type put(iter_type s, ios_base& f, char_type fill,
-                  double v) const;
-    iter_type put(iter_type s, ios_base& f, char_type fill,
-                  long double v) const;
-    iter_type put(iter_type s, ios_base& f, char_type fill,
-                  const void* v) const;
       static locale::id id;
     protected:
       ~num_put();
- virtual iter_type do_put(iter_type, ios_base&, char_type fill,
-                             bool v) const;
- virtual iter_type do_put(iter_type, ios_base&, char_type fill,
-                             long v) const;
- virtual iter_type do_put(iter_type, ios_base&, char_type fill,
-                             long long v) const;
- virtual iter_type do_put(iter_type, ios_base&, char_type fill,
-                             unsigned long) const;
-    virtual iter_type do_put(iter_type, ios_base&, char_type fill,
-                             unsigned long long) const;
-    virtual iter_type do_put(iter_type, ios_base&, char_type fill,
-                             double v) const;
-    virtual iter_type do_put(iter_type, ios_base&, char_type fill,
-                             long double v) const;
-    virtual iter_type do_put(iter_type, ios_base&, char_type fill,
-                             const void* v) const;
     };
 }
 ```
 The facet `num_put` is used to format numeric values to a character
 sequence such as an ostream.
 ##### `num_put` members <a id="facet.num.put.members">[[facet.num.put.members]]</a>
 ``` cpp
-iter_type put(iter_type out, ios_base& str, char_type fill,
-  bool val) const;
-iter_type put(iter_type out, ios_base& str, char_type fill,
- long val) const;
-iter_type put(iter_type out, ios_base& str, char_type fill,
-  long long val) const;
-iter_type put(iter_type out, ios_base& str, char_type fill,
-  unsigned long val) const;
-iter_type put(iter_type out, ios_base& str, char_type fill,
-  unsigned long long val) const;
-iter_type put(iter_type out, ios_base& str, char_type fill,
-  double val) const;
-iter_type put(iter_type out, ios_base& str, char_type fill,
-  long double val) const;
-iter_type put(iter_type out, ios_base& str, char_type fill,
-  const void* val) const;
 ```
 *Returns:* `do_put(out, str, fill, val)`.
 ##### `num_put` virtual functions <a id="facet.num.put.virtuals">[[facet.num.put.virtuals]]</a>
 ``` cpp
-iter_type do_put(iter_type out, ios_base& str, char_type fill,
- long val) const;
-iter_type do_put(iter_type out, ios_base& str, char_type fill,
- long long val) const;
-iter_type do_put(iter_type out, ios_base& str, char_type fill,
-  unsigned long val) const;
-iter_type do_put(iter_type out, ios_base& str, char_type fill,
-  unsigned long long val) const;
-iter_type do_put(iter_type out, ios_base& str, char_type fill,
-  double val) const;
-iter_type do_put(iter_type out, ios_base& str, char_type fill,
-  long double val) const;
-iter_type do_put(iter_type out, ios_base& str, char_type fill,
-  const void* val) const;
 ```
 *Effects:* Writes characters to the sequence `out`, formatting `val` as
-desired. In the following description, a local variable initialized with
 ``` cpp
 locale loc = str.getloc();
 ```
 The details of this operation occur in several stages:
-- Stage 1: Determine a printf conversion specifier `spec` and
- determining the characters that would be printed by
- `printf` ([[c.files]]) given this conversion specifier for
   ``` cpp
   printf(spec, val)
   ```
   assuming that the current locale is the `"C"` locale.
@@ -1235,10 +1221,11 @@ fmtflags flags = str.flags() ;
 fmtflags basefield =  (flags & (ios_base::basefield));
 fmtflags uppercase =  (flags & (ios_base::uppercase));
 fmtflags floatfield = (flags & (ios_base::floatfield));
 fmtflags showpos =    (flags & (ios_base::showpos));
 fmtflags showbase =   (flags & (ios_base::showbase));
 ```
 All tables used in describing stage 1 are ordered. That is, the first
 line whose condition is true applies. A line without a condition is the
 default behavior when none of the earlier lines apply.
@@ -1296,15 +1283,15 @@ qualifiers prepended as indicated in
 Table [[tab:localization.numeric.conversions]].
 **Table: Numeric conversions** <a id="tab:localization.numeric.conversions">[tab:localization.numeric.conversions]</a>
 | Type(s)               | State       | `stdio` equivalent |
-| --------------------- | ------------------- | ------------------ |
-| an integral type      | `flags & showpos`   | `+`                |
-|                       | `flags & showbase`  | `#`                |
-| a floating-point type | `flags & showpos`   | `+`                |
-|                       | `flags & showpoint` | `#`                |
 For conversion from a floating-point type, if
 `floatfield != (ios_base::fixed | ios_base::scientific)`,
 `str.precision()` is specified as precision in the conversion
@@ -1340,11 +1327,11 @@ A local variable is initialized as
 ``` cpp
 fmtflags adjustfield = (flags & (ios_base::adjustfield));
 ```
-The location of any padding[^11] is determined according to
 Table [[tab:localization.fill.padding]].
 **Table: Fill padding** <a id="tab:localization.fill.padding">[tab:localization.fill.padding]</a>
 | State                                                                          | Location           |
@@ -1370,12 +1357,11 @@ The sequence of `charT`’s at the end of stage 3 are output via
 ``` cpp
 *out++ = c
 ```
 ``` cpp
-iter_type do_put(iter_type out, ios_base& str, char_type fill,
-                 bool val) const;
 ```
 *Returns:* If `(str.flags() & ios_base::boolalpha) == 0` returns
 `do_put(out, str, fill,`
 `(int)val)`, otherwise obtains a string `s` as if by
@@ -1396,12 +1382,12 @@ and returns `out`.
 ``` cpp
 namespace std {
   template <class charT>
     class numpunct : public locale::facet {
     public:
-    typedef charT               char_type;
-    typedef basic_string<charT> string_type;
       explicit numpunct(size_t refs = 0);
       char_type    decimal_point()   const;
       char_type    thousands_sep()   const;
@@ -1460,23 +1446,23 @@ thousands-separators, no grouping constraint is applied.
 ``` cpp
 char_type decimal_point() const;
 ```
-*Returns:* `do_decimal_point()`
 ``` cpp
 char_type thousands_sep() const;
 ```
-*Returns:* `do_thousands_sep()`
 ``` cpp
 string grouping()  const;
 ```
-*Returns:* `do_grouping()`
 ``` cpp
 string_type truename()  const;
 string_type falsename() const;
 ```
@@ -1503,14 +1489,14 @@ required specializations return `’,’` or `L’,’`.
 string do_grouping() const;
 ```
 *Returns:* A basic_string\<char\> `vec` used as a vector of integer
 values, in which each element `vec[i]` represents the number of
-digits[^12] in the group at position `i`, starting with position 0 as
 the rightmost group. If `vec.size() <= i`, the number is the same as
-group `(i-1)`; if `(i<0 || vec[i]<=0 || vec[i]==CHAR_MAX)`, the size of
-the digit group is unlimited.
 The required specializations return the empty string, indicating no
 grouping.
 ``` cpp
@@ -1530,12 +1516,13 @@ or `L"true"` and `L"false"`.
 namespace std {
   template <class charT>
   class numpunct_byname : public numpunct<charT> {
   // this class is specialized for char and wchar_t.
   public:
- typedef charT                char_type;
- typedef basic_string<charT>  string_type;
     explicit numpunct_byname(const char*, size_t refs = 0);
     explicit numpunct_byname(const string&, size_t refs = 0);
   protected:
     ~numpunct_byname();
   };
@@ -1549,12 +1536,12 @@ namespace std {
 ``` cpp
 namespace std {
   template <class charT>
     class collate : public locale::facet {
     public:
-    typedef charT               char_type;
-    typedef basic_string<charT> string_type;
       explicit collate(size_t refs = 0);
       int compare(const charT* low1, const charT* high1,
                   const charT* low2, const charT* high2) const;
@@ -1590,23 +1577,23 @@ Each function compares a string of characters `*p` in the range \[`low`,
 ``` cpp
 int compare(const charT* low1, const charT* high1,
             const charT* low2, const charT* high2) const;
 ```
-*Returns:* `do_compare(low1, high1, low2, high2)`
 ``` cpp
 string_type transform(const charT* low, const charT* high) const;
 ```
-*Returns:* `do_transform(low, high)`
 ``` cpp
 long hash(const charT* low, const charT* high) const;
 ```
-*Returns:* `do_hash(low, high)`
 ##### `collate` virtual functions <a id="locale.collate.virtuals">[[locale.collate.virtuals]]</a>
 ``` cpp
 int do_compare(const charT* low1, const charT* high1,
@@ -1624,30 +1611,33 @@ string_type do_transform(const charT* low, const charT* high) const;
 ```
 *Returns:* A `basic_string<charT>` value that, compared
 lexicographically with the result of calling `transform()` on another
 string, yields the same result as calling `do_compare()` on the same two
-strings.[^13]
 ``` cpp
 long do_hash(const charT* low, const charT* high) const;
 ```
 *Returns:* An integer value equal to the result of calling `hash()` on
 any other string for which `do_compare()` returns 0 (equal) when passed
-the two strings. The probability that the result equals that for another
 string which does not compare equal should be very small, approaching
-`(1.0/numeric_limits<unsigned long>::max())`.
 #### Class template `collate_byname` <a id="locale.collate.byname">[[locale.collate.byname]]</a>
 ``` cpp
 namespace std {
   template <class charT>
     class collate_byname : public collate<charT> {
     public:
-    typedef basic_string<charT> string_type;
       explicit collate_byname(const char*, size_t refs = 0);
       explicit collate_byname(const string&, size_t refs = 0);
     protected:
       ~collate_byname();
     };
@@ -1661,12 +1651,12 @@ Templates `time_get<charT,InputIterator>` and
 parsing. All specifications of member functions for `time_put` and
 `time_get` in the subclauses of  [[category.time]] only apply to the
 specializations required in Tables  [[tab:localization.category.facets]]
 and  [[tab:localization.required.specializations]] (
 [[locale.category]]). Their members use their `ios_base&`,
-`ios_base::iostate&`, and `fill` arguments as described in (
-[[locale.categories]]), and the `ctype<>` facet, to determine formatting
 details.
 #### Class template `time_get` <a id="locale.time.get">[[locale.time.get]]</a>
 ``` cpp
@@ -1677,12 +1667,12 @@ namespace std {
   };
   template <class charT, class InputIterator = istreambuf_iterator<charT>>
     class time_get : public locale::facet, public time_base {
     public:
-    typedef charT            char_type;
-    typedef InputIterator    iter_type;
       explicit time_get(size_t refs = 0);
       dateorder date_order()  const { return do_date_order(); }
       iter_type get_time(iter_type s, iter_type end, ios_base& f,
@@ -1723,81 +1713,81 @@ namespace std {
 ```
 `time_get`
 is used to parse a character sequence, extracting components of a time
-or date into a `struct tm` record. Each `get` member parses a format as
 produced by a corresponding format specifier to `time_put<>::put`. If
 the sequence being parsed matches the correct format, the corresponding
 members of the `struct tm` argument are set to the values used to
 produce the sequence; otherwise either an error is reported or
-unspecified values are assigned.[^14]
 If the end iterator is reached during parsing by any of the `get()`
 member functions, the member sets `ios_base::eofbit` in `err`.
 ##### `time_get` members <a id="locale.time.get.members">[[locale.time.get.members]]</a>
 ``` cpp
 dateorder date_order() const;
 ```
-*Returns:* `do_date_order()`
 ``` cpp
 iter_type get_time(iter_type s, iter_type end, ios_base& str,
                    ios_base::iostate& err, tm* t) const;
 ```
-*Returns:* `do_get_time(s, end, str, err, t)`
 ``` cpp
 iter_type get_date(iter_type s, iter_type end, ios_base& str,
                    ios_base::iostate& err, tm* t) const;
 ```
-*Returns:* `do_get_date(s, end, str, err, t)`
 ``` cpp
 iter_type get_weekday(iter_type s, iter_type end, ios_base& str,
                       ios_base::iostate& err, tm* t) const;
 iter_type get_monthname(iter_type s, iter_type end, ios_base& str,
                         ios_base::iostate& err, tm* t) const;
 ```
 *Returns:* `do_get_weekday(s, end, str, err, t)` or
-`do_get_monthname(s, end, str, err, t)`
 ``` cpp
 iter_type get_year(iter_type s, iter_type end, ios_base& str,
                    ios_base::iostate& err, tm* t) const;
 ```
-*Returns:* `do_get_year(s, end, str, err, t)`
 ``` cpp
-iter_type get(iter_type s, iter_type end, ios_base& f,
-    ios_base::iostate& err, tm* t, char format, char modifier = 0) const;
 ```
-*Returns:* `do_get(s, end, f, err, t, format, modifier)`
 ``` cpp
-iter_type get(iter_type s, iter_type end, ios_base& f,
-    ios_base::iostate& err, tm* t, const char_type* fmt, const char_type* fmtend) const;
 ```
 *Requires:* \[`fmt`, `fmtend`) shall be a valid range.
 *Effects:* The function starts by evaluating `err = ios_base::goodbit`.
 It then enters a loop, reading zero or more characters from `s` at each
 iteration. Unless otherwise specified below, the loop terminates when
 the first of the following conditions holds:
-- The expression `fmt == fmtend` evaluates to true.
-- The expression `err == ios_base::goodbit` evaluates to false.
-- The expression `s == end` evaluates to true, in which case the
   function evaluates `err = ios_base::eofbit | ios_base::failbit`.
 - The next element of `fmt` is equal to `’%’`, optionally followed by a
   modifier character, followed by a conversion specifier character,
   `format`, together forming a conversion specification valid for the
   ISO/IEC 9945 function `strptime`. If the number of elements in the
@@ -1808,36 +1798,37 @@ the first of the following conditions holds:
   value of `modifier` is `’\0’` when the optional modifier is absent
   from the conversion specification. If `err == ios_base::goodbit` holds
   after the evaluation of the expression, the function increments `fmt`
   to point just past the end of the conversion specification and
   continues looping.
-- The expression `isspace(*fmt, f.getloc())` evaluates to true, in which
-  case the function first increments `fmt` until
-  `fmt == fmtend || !isspace(*fmt, f.getloc())` evaluates to true, then
-  advances `s` until `s == end || !isspace(*s, f.getloc())` is true, and
-  finally resumes looping.
 - The next character read from `s` matches the element pointed to by
   `fmt` in a case-insensitive comparison, in which case the function
   evaluates `++fmt, ++s` and continues looping. Otherwise, the function
   evaluates `err = ios_base::failbit`.
-The function uses the `ctype<charT>` facet installed in `f`’s locale to
-determine valid whitespace characters. It is unspecified by what means
-the function performs case-insensitive comparison or whether
-multi-character sequences are considered while doing so.
-*Returns:* `s`
 ##### `time_get` virtual functions <a id="locale.time.get.virtuals">[[locale.time.get.virtuals]]</a>
 ``` cpp
 dateorder do_date_order() const;
 ```
 *Returns:* An enumeration value indicating the preferred order of
 components for those date formats that are composed of day, month, and
-year.[^15] Returns `no_order` if the date format specified by `’x’`
 contains other variable components (e.g., Julian day, week number, week
 day).
 ``` cpp
 iter_type do_get_time(iter_type s, iter_type end, ios_base& str,
@@ -1924,24 +1915,24 @@ any remaining format characters, corresponding to a conversion directive
 appropriate for the ISO/IEC 9945 function `strptime`, formed by
 concatenating `’%’`, the `modifier` character, when non-NUL, and the
 `format` character. When the concatenation fails to yield a complete
 valid directive the function leaves the object pointed to by `t`
 unchanged and evaluates `err |= ios_base::failbit`. When `s == end`
-evaluates to true after reading a character the function evaluates
 `err |= ios_base::eofbit`.
 For complex conversion directives such as `%c`, `%x`, or `%X`, or
 directives that involve the optional modifiers `E` or `O`, when the
 function is unable to unambiguously determine some or all `struct tm`
 members from the input sequence \[`s`, `end`), it evaluates
 `err |= ios_base::eofbit`. In such cases the values of those `struct tm`
 members are unspecified and may be outside their valid range.
-It is unspecified whether multiple calls to `do_get()` with the address
-of the same `struct tm` object will update the current contents of the
-object or simply overwrite its members. Portable programs must zero out
-the object before invoking the function.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as possibly part of a valid input sequence for the given
 `format` and `modifier`.
@@ -1950,12 +1941,12 @@ recognized as possibly part of a valid input sequence for the given
 ``` cpp
 namespace std {
   template <class charT, class InputIterator = istreambuf_iterator<charT>>
   class time_get_byname : public time_get<charT, InputIterator> {
   public:
- typedef time_base::dateorder dateorder;
- typedef InputIterator        iter_type;
     explicit time_get_byname(const char*, size_t refs = 0);
     explicit time_get_byname(const string&, size_t refs = 0);
   protected:
     ~time_get_byname();
@@ -1968,12 +1959,12 @@ namespace std {
 ``` cpp
 namespace std {
   template <class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class time_put : public locale::facet {
     public:
-    typedef charT            char_type;
-    typedef OutputIterator   iter_type;
       explicit time_put(size_t refs = 0);
       // the following is implemented in terms of other member functions.
       iter_type put(iter_type s, ios_base& f, char_type fill, const tm* tmb,
@@ -2008,20 +1999,20 @@ call to `do_put`; thus, format elements and other characters are
 interleaved in the output in the order in which they appear in the
 pattern. Format sequences are identified by converting each character
 `c` to a `char` value as if by `ct.narrow(c, 0)`, where `ct` is a
 reference to `ctype<charT>` obtained from `str.getloc()`. The first
 character of each sequence is equal to `’%’`, followed by an optional
-modifier character `mod`[^16] and a format specifier character `spec` as
 defined for the function `strftime`. If no modifier character is
 present, `mod` is zero. For each valid format sequence identified, calls
 `do_put(s, str, fill, t, spec, mod)`.
 The second form calls `do_put(s, str, fill, t, format, modifier)`.
-The `fill` argument may be used in the implementation-defined formats or
-by derivations. A space character is a reasonable default for this
-argument.
 *Returns:* An iterator pointing immediately after the last character
 produced.
 ##### `time_put` virtual functions <a id="locale.time.put.virtuals">[[locale.time.put.virtuals]]</a>
@@ -2033,29 +2024,31 @@ iter_type do_put(iter_type s, ios_base&, char_type fill, const tm* t,
 *Effects:* Formats the contents of the parameter `t` into characters
 placed on the output sequence `s`. Formatting is controlled by the
 parameters `format` and `modifier`, interpreted identically as the
 format specifiers in the string argument to the standard library
-function `strftime()`[^17], except that the sequence of characters
 produced for those specifiers that are described as depending on the C
-locale are instead *implementation-defined*.[^18]
 *Returns:* An iterator pointing immediately after the last character
-produced. The `fill` argument may be used in the implementation-defined
-formats or by derivations. A space character is a reasonable default for
-this argument.
 #### Class template `time_put_byname` <a id="locale.time.put.byname">[[locale.time.put.byname]]</a>
 ``` cpp
 namespace std {
   template <class charT, class OutputIterator = ostreambuf_iterator<charT>>
   class time_put_byname : public time_put<charT, OutputIterator>
   {
   public:
- typedef charT          char_type;
- typedef OutputIterator iter_type;
     explicit time_put_byname(const char*, size_t refs = 0);
     explicit time_put_byname(const string&, size_t refs = 0);
   protected:
     ~time_put_byname();
@@ -2071,25 +2064,24 @@ whether local or international monetary formats are to be used.
 All specifications of member functions for `money_put` and `money_get`
 in the subclauses of  [[category.monetary]] only apply to the
 specializations required in Tables  [[tab:localization.category.facets]]
 and  [[tab:localization.required.specializations]] (
 [[locale.category]]). Their members use their `ios_base&`,
-`ios_base :: iostate&`, and `fill` arguments as described in (
-[[locale.categories]]), and the `moneypunct<>` and `ctype<>` facets, to
 determine formatting details.
 #### Class template `money_get` <a id="locale.money.get">[[locale.money.get]]</a>
 ``` cpp
 namespace std {
-  template <class charT,
-    class InputIterator = istreambuf_iterator<charT> >
     class money_get : public locale::facet {
     public:
-    typedef charT               char_type;
-    typedef InputIterator       iter_type;
-    typedef basic_string<charT> string_type;
       explicit money_get(size_t refs = 0);
       iter_type get(iter_type s, iter_type end, bool intl,
                     ios_base& f, ios_base::iostate& err,
@@ -2118,11 +2110,11 @@ iter_type get(iter_type s, iter_type end, bool intl,
               long double& quant) const;
 iter_type get(s, iter_type end, bool intl, ios_base&f,
               ios_base::iostate& err, string_type& quant) const;
 ```
-*Returns:* `do_get(s, end, intl, f, err, quant)`
 ##### `money_get` virtual functions <a id="locale.money.get.virtuals">[[locale.money.get.virtuals]]</a>
 ``` cpp
 iter_type do_get(iter_type s, iter_type end, bool intl,
@@ -2143,13 +2135,17 @@ does not change `err`; otherwise, sets `err` to `(err|str.failbit)`, or
 does not change `units` or `digits`. Uses the pattern returned by
 `mp.neg_format()` to parse all values. The result is returned as an
 integral value stored in `units` or as a sequence of digits possibly
 preceded by a minus sign (as produced by `ct.widen(c)` where `c` is
 `’-’` or in the range from `’0’` through `’9’`, inclusive) stored in
-`digits`. The sequence `$1,056.23` in a common United States locale
-would yield, for `units`, `105623`, or, for `digits`, `"105623"`. If
-`mp.grouping()` indicates that no thousands separators are permitted,
 any such characters are not read, and parsing is terminated at the point
 where they first appear. Otherwise, thousands separators are optional;
 if present, they are checked for correct placement only after all format
 components have been read.
@@ -2165,27 +2161,30 @@ format; otherwise, the currency symbol is required.
 If the first character (if any) in the string `pos` returned by
 `mp.positive_sign()` or the string `neg` returned by
 `mp.negative_sign()` is recognized in the position indicated by `sign`
 in the format pattern, it is consumed and any remaining characters in
-the string are required after all the other format components. If
-`showbase` is off, then for a `neg` value of `"()"` and a currency
-symbol of `"L"`, in `"(100 L)"` the `"L"` is consumed; but if `neg` is
-`"-"`, the `"L"` in `"-100 L"` is not consumed. If `pos` or `neg` is
-empty, the sign component is optional, and if no sign is detected, the
-result is given the sign that corresponds to the source of the empty
-string. Otherwise, the character in the indicated position must match
-the first character of `pos` or `neg`, and the result is given the
-corresponding sign. If the first character of `pos` is equal to the
-first character of `neg`, or if both strings are empty, the result is
-given a positive sign.
 Digits in the numeric monetary component are extracted and placed in
 `digits`, or into a character buffer `buf1` for conversion to produce a
 value for `units`, in the order in which they appear, preceded by a
 minus sign if and only if the result is negative. The value `units` is
-produced as if by[^19]
 ``` cpp
 for (int i = 0; i < n; ++i)
   buf2[i] = src[find(atoms, atoms+sizeof(src), buf1[i]) - atoms];
 buf2[n] = 0;
@@ -2206,17 +2205,16 @@ recognized as part of a valid monetary quantity.
 #### Class template `money_put` <a id="locale.money.put">[[locale.money.put]]</a>
 ``` cpp
 namespace std {
-  template <class charT,
-    class OutputIterator = ostreambuf_iterator<charT> >
     class money_put : public locale::facet {
     public:
-    typedef charT               char_type;
-    typedef OutputIterator      iter_type;
-    typedef basic_string<charT> string_type;
       explicit money_put(size_t refs = 0);
       iter_type put(iter_type s, bool intl, ios_base& f,
                     char_type fill, long double units) const;
@@ -2242,11 +2240,11 @@ iter_type put(iter_type s, bool intl, ios_base& f, char_type fill,
               long double quant) const;
 iter_type put(iter_type s, bool intl, ios_base& f, char_type fill,
               const string_type& quant) const;
 ```
-*Returns:* `do_put(s, intl, f, loc, quant)`
 ##### `money_put` virtual functions <a id="locale.money.put.virtuals">[[locale.money.put.virtuals]]</a>
 ``` cpp
 iter_type do_put(iter_type s, bool intl, ios_base& str,
@@ -2281,16 +2279,18 @@ Calls `str.width(0)`.
 `(str.flags() & str.showbase)` is nonzero. If the number of characters
 generated for the specified format is less than the value returned by
 `str.width()` on entry to the function, then copies of `fill` are
 inserted as necessary to pad to the specified width. For the value `af`
 equal to `(str.flags() & str.adjustfield)`, if `(af == str.internal)` is
-true, the fill characters are placed where `none` or `space` appears in
-the formatting pattern; otherwise if `(af == str.left)` is true, they
-are placed after the other characters; otherwise, they are placed before
-the other characters. It is possible, with some combinations of format
-patterns and flag values, to produce output that cannot be parsed using
-`num_get<>::get`.
 *Returns:* An iterator pointing immediately after the last character
 produced.
 #### Class template `moneypunct` <a id="locale.moneypunct">[[locale.moneypunct]]</a>
@@ -2304,12 +2304,12 @@ namespace std {
   };
   template <class charT, bool International = false>
     class moneypunct : public locale::facet, public money_base {
     public:
-    typedef charT char_type;
-    typedef basic_string<charT> string_type;
       explicit moneypunct(size_t refs = 0);
       charT        decimal_point() const;
       charT        thousands_sep() const;
@@ -2341,11 +2341,11 @@ namespace std {
 The `moneypunct<>` facet defines monetary formatting parameters used by
 `money_get<>` and `money_put<>`. A monetary format is a sequence of four
 components, specified by a `pattern` value `p`, such that the `part`
 value `static_cast<part>(p.field[i])` determines the `i`th component of
-the format[^20] In the `field` member of a `pattern` object, each value
 `symbol`, `sign`, `value`, and either `space` or `none` appears exactly
 once. The value `none`, if present, is not first; the value `space`, if
 present, is neither first nor last.
 Where `none` or `space` appears, white space is permitted in the format,
@@ -2408,56 +2408,56 @@ int          frac_digits()   const;
 pattern      pos_format()    const;
 pattern      neg_format()    const;
 ```
 Each of these functions `F` returns the result of calling the
-corresponding virtual member function `do_`***F***`()`.
 ##### `moneypunct` virtual functions <a id="locale.moneypunct.virtuals">[[locale.moneypunct.virtuals]]</a>
 ``` cpp
 charT do_decimal_point() const;
 ```
 *Returns:* The radix separator to use in case `do_frac_digits()` is
-greater than zero.[^21]
 ``` cpp
 charT do_thousands_sep() const;
 ```
 *Returns:* The digit group separator to use in case `do_grouping()`
-specifies a digit grouping pattern.[^22]
 ``` cpp
 string do_grouping() const;
 ```
 *Returns:* A pattern defined identically as, but not necessarily equal
-to, the result of `numpunct<charT>::do_grouping()`.[^23]
 ``` cpp
 string_type do_curr_symbol() const;
 ```
-*Returns:* A string to use as the currency identifier symbol.[^24]
 ``` cpp
 string_type do_positive_sign() const;
 string_type do_negative_sign() const;
 ```
 *Returns:* `do_positive_sign()` returns the string to use to indicate a
-positive monetary value;[^25] `do_negative_sign()` returns the string to
 use to indicate a negative value.
 ``` cpp
 int do_frac_digits() const;
 ```
 *Returns:* The number of digits after the decimal radix separator, if
-any.[^26]
 ``` cpp
 pattern do_pos_format() const;
 pattern do_neg_format() const;
 ```
@@ -2465,21 +2465,21 @@ pattern do_neg_format() const;
 *Returns:* The specializations required in
 Table  [[tab:localization.required.specializations]] ([[locale.category]]),
 namely `moneypunct<char>`, `moneypunct<wchar_t>`,
 `moneypunct<char, true>`, and `moneypunct<wchar_t, true>`, return an
 object of type `pattern` initialized to
-`{ symbol, sign, none, value }`.[^27]
 #### Class template `moneypunct_byname` <a id="locale.moneypunct.byname">[[locale.moneypunct.byname]]</a>
 ``` cpp
 namespace std {
   template <class charT, bool Intl = false>
   class moneypunct_byname : public moneypunct<charT, Intl> {
   public:
- typedef money_base::pattern pattern;
- typedef basic_string<charT> string_type;
     explicit moneypunct_byname(const char*, size_t refs = 0);
     explicit moneypunct_byname(const string&, size_t refs = 0);
   protected:
     ~moneypunct_byname();
@@ -2496,18 +2496,18 @@ catalogs.
 ``` cpp
 namespace std {
   class messages_base {
   public:
- typedef unspecified signed integer type catalog;
   };
   template <class charT>
     class messages : public locale::facet, public messages_base {
     public:
-    typedef charT char_type;
-    typedef basic_string<charT> string_type;
       explicit messages(size_t refs = 0);
       catalog open(const basic_string<char>& fn, const locale&) const;
       string_type get(catalog c, int set, int msgid,
@@ -2536,12 +2536,11 @@ catalog open(const basic_string<char>& name, const locale& loc) const;
 ```
 *Returns:* `do_open(name, loc)`.
 ``` cpp
-string_type get(catalog cat, int set, int msgid,
-                const string_type& dfault) const;
 ```
 *Returns:* `do_get(cat, set, msgid, dfault)`.
 ``` cpp
@@ -2551,12 +2550,11 @@ void  close(catalog cat) const;
 *Effects:* Calls `do_close(cat)`.
 ##### `messages` virtual functions <a id="locale.messages.virtuals">[[locale.messages.virtuals]]</a>
 ``` cpp
-catalog do_open(const basic_string<char>& name,
-                const locale& loc) const;
 ```
 *Returns:* A value that may be passed to `get()` to retrieve a message
 from the message catalog identified by the string `name` according to an
 *implementation-defined* mapping. The result can be used until it is
@@ -2566,12 +2564,11 @@ Returns a value less than 0 if no such catalog can be opened.
 *Remarks:* The locale argument `loc` is used for character set code
 conversion when retrieving messages, if needed.
 ``` cpp
-string_type do_get(catalog cat, int set, int msgid,
-              const string_type& dfault) const;
 ```
 *Requires:* `cat` shall be a catalog obtained from `open()` and not yet
 closed.
@@ -2587,21 +2584,21 @@ void do_close(catalog cat) const;
 closed.
 *Effects:* Releases unspecified resources associated with `cat`.
 *Remarks:* The limit on such resources, if any, is
-implementation-defined.
 #### Class template `messages_byname` <a id="locale.messages.byname">[[locale.messages.byname]]</a>
 ``` cpp
 namespace std {
   template <class charT>
   class messages_byname : public messages<charT> {
   public:
- typedef messages_base::catalog catalog;
- typedef basic_string<charT>    string_type;
     explicit messages_byname(const char*, size_t refs = 0);
     explicit messages_byname(const string&, size_t refs = 0);
   protected:
     ~messages_byname();
@@ -2614,11 +2611,14 @@ namespace std {
 A C++program may define facets to be added to a locale and used
 identically as the built-in facets. To create a new facet interface,
 C++programs simply derive from `locale::facet` a class containing a
 static member: `static locale::id id`.
-The locale member function templates verify its type and storage class.
 Traditional global localization is still easy:
 ``` cpp
 #include <iostream>
@@ -2636,10 +2636,14 @@ int main(int argc, char** argv) {
   return MyObject(argc, argv).doit();
 }
 ```
 Greater flexibility is possible:
 ``` cpp
 #include <iostream>
 #include <locale>
@@ -2653,13 +2657,17 @@ int main() {
 }
 ```
 In a European locale, with input `3.456,78`, output is `3456.78`.
 This can be important even for simple programs, which may need to write
 a data file in a fixed format, regardless of a user’s preference.
 Here is an example of the use of locales in a library interface.
 ``` cpp
 // file: Date.h
 #include <iosfwd>
@@ -2707,15 +2715,19 @@ std::istream& operator>>(std::istream& s, Date& d) {
   }
   return s;
 }
 ```
 A locale object may be extended with a new facet simply by constructing
 it with an instance of a class derived from `locale::facet`. The only
 member a C++program must define is the static member `id`, which
 identifies your class interface as a new facet.
 Classifying Japanese characters:
 ``` cpp
 // file: <jctype>
 #include <locale>
@@ -2737,33 +2749,36 @@ namespace My {
 #include "jctype"               // above
 std::locale::id My::JCtype::id; // the static JCtype member declared above.
 int main() {
   using namespace std;
- typedef ctype<wchar_t> wctype;
   locale loc(locale(""),        // the user's preferred locale ...
          new My::JCtype);       // and a new feature ...
   wchar_t c = use_facet<wctype>(loc).widen('!');
   if (!use_facet<My::JCtype>(loc).is_kanji(c))
     cout << "no it isn't!" << endl;
-  return 0;
 }
 ```
 The new facet is used exactly like the built-in facets.
 Replacing an existing facet is even easier. The code does not define a
 member `id` because it is reusing the `numpunct<charT>` facet interface:
 ``` cpp
 // file: my_bool.C
 #include <iostream>
 #include <locale>
 #include <string>
 namespace My {
   using namespace std;
- typedef numpunct_byname<char> cnumpunct;
   class BoolNames : public cnumpunct {
   protected:
     string do_truename()  const { return "Oui Oui!"; }
     string do_falsename() const { return "Mais Non!"; }
     ~BoolNames() { }
@@ -2776,9 +2791,10 @@ int main(int argc, char** argv) {
   using namespace std;
   // make the user's preferred locale, except for...
   locale loc(locale(""), new My::BoolNames(""));
   cout.imbue(loc);
   cout << boolalpha << "Any arguments today? " << (argc > 1) << endl;
-  return 0;
 }
 ```

 ``` cpp
 namespace std {
   class ctype_base {
   public:
+ using mask = T;
     // numeric values are for exposition only.
     static const mask space = 1 << 0;
     static const mask print = 1 << 1;
     static const mask cntrl = 1 << 2;
 ``` cpp
 namespace std {
   template <class charT>
     class ctype : public locale::facet, public ctype_base {
     public:
+      using char_type = charT;
       explicit ctype(size_t refs = 0);
       bool         is(mask m, charT c) const;
       const charT* is(const charT* low, const charT* high, mask* vec) const;
+ const charT* scan_is(mask m, const charT* low, const charT* high) const;
+ const charT* scan_not(mask m, const charT* low, const charT* high) const;
       charT        toupper(charT c) const;
       const charT* toupper(charT* low, const charT* high) const;
       charT        tolower(charT c) const;
       const charT* tolower(charT* low, const charT* high) const;
       charT        widen(char c) const;
       const char*  widen(const char* low, const char* high, charT* to) const;
       char         narrow(charT c, char dfault) const;
+ const charT* narrow(const charT* low, const charT* high, char dfault, char* to) const;
       static locale::id id;
     protected:
       ~ctype();
       virtual bool         do_is(mask m, charT c) const;
+ virtual const charT* do_is(const charT* low, const charT* high, mask* vec) const;
+      virtual const charT* do_scan_is(mask m, const charT* low, const charT* high) const;
+ virtual const charT* do_scan_not(mask m, const charT* low, const charT* high) const;
       virtual charT        do_toupper(charT) const;
       virtual const charT* do_toupper(charT* low, const charT* high) const;
       virtual charT        do_tolower(charT) const;
       virtual const charT* do_tolower(charT* low, const charT* high) const;
       virtual charT        do_widen(char) const;
+ virtual const char*  do_widen(const char* low, const char* high, charT* dest) const;
       virtual char         do_narrow(charT, char dfault) const;
       virtual const charT* do_narrow(const charT* low, const charT* high,
                                      char dfault, char* dest) const;
     };
 }
 bool         is(mask m, charT c) const;
 const charT* is(const charT* low, const charT* high,
                 mask* vec) const;
 ```
+*Returns:* `do_is(m, c)` or `do_is(low, high, vec)`.
 ``` cpp
 const charT* scan_is(mask m,
                      const charT* low, const charT* high) const;
 ```
+*Returns:* `do_scan_is(m, low, high)`.
 ``` cpp
 const charT* scan_not(mask m,
                       const charT* low, const charT* high) const;
 ```
+*Returns:* `do_scan_not(m, low, high)`.
 ``` cpp
 charT        toupper(charT) const;
 const charT* toupper(charT* low, const charT* high) const;
 ```
+*Returns:* `do_toupper(c)` or `do_toupper(low, high)`.
 ``` cpp
 charT        tolower(charT c) const;
 const charT* tolower(charT* low, const charT* high) const;
 ```
+*Returns:* `do_tolower(c)` or `do_tolower(low, high)`.
 ``` cpp
 charT       widen(char c) const;
 const char* widen(const char* low, const char* high, charT* to) const;
 ```
+*Returns:* `do_widen(c)` or `do_widen(low, high, to)`.
 ``` cpp
 char         narrow(charT c, char dfault) const;
+const charT* narrow(const charT* low, const charT* high, char dfault,
                     char* to) const;
 ```
+*Returns:* `do_narrow(c, dfault)` or `do_narrow(low, high, dfault, to)`.
 ##### `ctype` virtual functions <a id="locale.ctype.virtuals">[[locale.ctype.virtuals]]</a>
 ``` cpp
 bool         do_is(mask m, charT c) const;
 ```
 *Effects:* Classifies a character or sequence of characters. For each
 argument character, identifies a value `M` of type `ctype_base::mask`.
 The second form identifies a value `M` of type `ctype_base::mask` for
+each `*p` where `(low <= p && p < high)`, and places it into
+`vec[p - low]`.
 *Returns:* The first form returns the result of the expression
 `(M & m) != 0`; i.e., `true` if the character has the characteristics
 specified. The second form returns `high`.
 ``` cpp
+const charT* do_scan_is(mask m, const charT* low, const charT* high) const;
 ```
 *Effects:* Locates a character in a buffer that conforms to a
 classification `m`.
+*Returns:* The smallest pointer `p` in the range \[`low`, `high`) such
+that `is(m, *p)` would return `true`; otherwise, returns `high`.
 ``` cpp
+const charT* do_scan_not(mask m, const charT* low, const charT* high) const;
 ```
 *Effects:* Locates a character in a buffer that fails to conform to a
 classification `m`.
                       charT* dest) const;
 ```
 *Effects:* Applies the simplest reasonable transformation from a `char`
 value or sequence of `char` values to the corresponding `charT` value or
+values.[^5] The only characters for which unique transformations are
 required are those in the basic source character set ([[lex.charset]]).
 For any named `ctype` category with a `ctype <charT>` facet `ctc` and
 valid `ctype_base::mask` value `M`,
+`(ctc.is(M, c) || !is(M, do_widen(c)) )` is `true`.[^6]
 The second form transforms each character `*p` in the range \[`low`,
 `high`), placing the result in `dest[p - low]`.
 *Returns:* The first form returns the transformed value. The second form
 ``` cpp
 namespace std {
   template <class charT>
     class ctype_byname : public ctype<charT> {
     public:
+      using mask = typename ctype<charT>::mask;
       explicit ctype_byname(const char*, size_t refs = 0);
       explicit ctype_byname(const string&, size_t refs = 0);
     protected:
       ~ctype_byname();
     };
 #### `ctype` specializations <a id="facet.ctype.special">[[facet.ctype.special]]</a>
 ``` cpp
 namespace std {
+  template <>
+ class ctype<char> : public locale::facet, public ctype_base {
     public:
+      using char_type = char;
       explicit ctype(const mask* tab = 0, bool del = false,
                      size_t refs = 0);
       bool is(mask m, char c) const;
     };
 }
 ```
 A specialization `ctype<char>` is provided so that the member functions
+on type `char` can be implemented `inline`.[^7] The
 *implementation-defined* value of member `table_size` is at least 256.
 ##### `ctype<char>` destructor <a id="facet.ctype.char.dtor">[[facet.ctype.char.dtor]]</a>
 ``` cpp
 ~ctype();
 ```
 *Effects:* If the constructor’s first argument was nonzero, and its
+second argument was `true`, does `delete [] table()`.
 ##### `ctype<char>` members <a id="facet.ctype.char.members">[[facet.ctype.char.members]]</a>
 In the following member descriptions, for `unsigned char` values `v`
 where `v >= table_size`, `table()[v]` is assumed to have an
 ``` cpp
 explicit ctype(const mask* tbl = 0, bool del = false,
                size_t refs = 0);
 ```
+*Requires:* `tbl` either 0 or an array of at least `table_size`
+elements.
 *Effects:* Passes its `refs` argument to its base class constructor.
 ``` cpp
 bool        is(mask m, char c) const;
 const char* is(const char* low, const char* high,
                mask* vec) const;
 ```
 *Effects:* The second form, for all `*p` in the range \[`low`, `high`),
+assigns into `vec[p - low]` the value `table()[(unsigned char)*p]`.
 *Returns:* The first form returns `table()[(unsigned char)c] & m`; the
 second form returns `high`.
 ``` cpp
 ``` cpp
 const mask* table() const noexcept;
 ```
+*Returns:* The first constructor argument, if it was nonzero, otherwise
 `classic_table()`.
 ##### `ctype<char>` static members <a id="facet.ctype.char.statics">[[facet.ctype.char.statics]]</a>
 ``` cpp
 static const mask* classic_table() noexcept;
 ```
 *Returns:* A pointer to the initial element of an array of size
 `table_size` which represents the classifications of characters in the
+`"C"` locale.
 ##### `ctype<char>` virtual functions <a id="facet.ctype.char.virtuals">[[facet.ctype.char.virtuals]]</a>
 ``` cpp
 char        do_toupper(char) const;
   };
   template <class internT, class externT, class stateT>
     class codecvt : public locale::facet, public codecvt_base {
     public:
+      using intern_type = internT;
+      using extern_type = externT;
+      using state_type  = stateT;
       explicit codecvt(size_t refs = 0);
+ result out(
+          stateT& state,
           const internT* from, const internT* from_end, const internT*& from_next,
                 externT*   to,       externT*   to_end,       externT*&   to_next) const;
+      result unshift(
+          stateT& state,
                 externT*    to,      externT*   to_end,       externT*&   to_next) const;
+      result in(
+          stateT& state,
           const externT* from, const externT* from_end, const externT*& from_next,
                 internT*   to,       internT*   to_end,       internT*&   to_next) const;
       int encoding() const noexcept;
       bool always_noconv() const noexcept;
+ int length(stateT&, const externT* from, const externT* end, size_t max) const;
       int max_length() const noexcept;
       static locale::id id;
     protected:
       ~codecvt();
+ virtual result do_out(
+          stateT& state,
           const internT* from, const internT* from_end, const internT*& from_next,
                 externT* to,         externT*   to_end,       externT*&   to_next) const;
+ virtual result do_in(
+          stateT& state,
           const externT* from, const externT* from_end, const externT*& from_next,
                 internT* to,         internT*   to_end,       internT*&   to_next) const;
+ virtual result do_unshift(
+          stateT& state,
                 externT* to,         externT*   to_end,       externT*&   to_next) const;
       virtual int do_encoding() const noexcept;
       virtual bool do_always_noconv() const noexcept;
+ virtual int do_length(stateT&, const externT* from, const externT* end, size_t max) const;
       virtual int do_max_length() const noexcept;
     };
 }
 ```
 The specializations required in Table
 [[tab:localization.category.facets]] ([[locale.category]]) convert the
 implementation-defined native character set.
 `codecvt<char, char, mbstate_t>` implements a degenerate conversion; it
+does not convert at all. The specialization
+`codecvt<char16_t, char, mbstate_t>` converts between the UTF-16 and
+UTF-8 encoding forms, and the specialization `codecvt`
+`<char32_t, char, mbstate_t>` converts between the UTF-32 and UTF-8
+encoding forms. `codecvt<wchar_t, char, mbstate_t>` converts between the
+native character sets for narrow and wide characters. Specializations on
+`mbstate_t` perform conversion between encodings known to the library
+implementer. Other encodings can be converted by specializing on a
+user-defined `stateT` type. Objects of type `stateT` can contain any
+state that is useful to communicate to or from the specialized `do_in`
+or `do_out` members.
 ##### `codecvt` members <a id="locale.codecvt.members">[[locale.codecvt.members]]</a>
 ``` cpp
+result out(
+    stateT& state,
     const internT* from, const internT* from_end, const internT*& from_next,
     externT* to, externT* to_end, externT*& to_next) const;
 ```
 *Returns:*
+`do_out(state, from, from_end, from_next, to, to_end, to_next)`.
 ``` cpp
+result unshift(stateT& state, externT* to, externT* to_end, externT*& to_next) const;
 ```
+*Returns:* `do_unshift(state, to, to_end, to_next)`.
 ``` cpp
+result in(
+    stateT& state,
     const externT* from, const externT* from_end, const externT*& from_next,
     internT* to, internT* to_end, internT*& to_next) const;
 ```
 *Returns:*
+`do_in(state, from, from_end, from_next, to, to_end, to_next)`.
 ``` cpp
 int encoding() const noexcept;
 ```
+*Returns:* `do_encoding()`.
 ``` cpp
 bool always_noconv() const noexcept;
 ```
+*Returns:* `do_always_noconv()`.
 ``` cpp
+int length(stateT& state, const externT* from, const externT* from_end, size_t max) const;
 ```
+*Returns:* `do_length(state, from, from_end, max)`.
 ``` cpp
 int max_length() const noexcept;
 ```
+*Returns:* `do_max_length()`.
 ##### `codecvt` virtual functions <a id="locale.codecvt.virtuals">[[locale.codecvt.virtuals]]</a>
 ``` cpp
+result do_out(
+    stateT& state,
     const internT* from, const internT* from_end, const internT*& from_next,
     externT* to, externT* to_end, externT*& to_next) const;
+result do_in(
+    stateT& state,
     const externT* from, const externT* from_end, const externT*& from_next,
     internT* to, internT* to_end, internT*& to_next) const;
 ```
+*Requires:* `(from <= from_end && to <= to_end)` well-defined and
 `true`; `state` initialized, if at the beginning of a sequence, or else
 equal to the result of converting the preceding characters in the
 sequence.
+*Effects:* Translates characters in the source range \[`from`,
+`from_end`), placing the results in sequential positions starting at
+destination `to`. Converts no more than `(from_end - from)` source
+elements, and stores no more than `(to_end - to)` destination elements.
 Stops if it encounters a character it cannot convert. It always leaves
 the `from_next` and `to_next` pointers pointing one beyond the last
 element successfully converted. If returns `noconv`, `internT` and
 `externT` are the same type and the converted sequence is identical to
+the input sequence \[`from`, `from``next`). `to_next` is set equal to
+`to`, the value of `state` is unchanged, and there are no changes to the
+values in \[`to`, `to_end`).
 A `codecvt` facet that is used by `basic_filebuf` ([[file.streams]])
 shall have the property that if
 ``` cpp
 ``` cpp
 do_in(state, from, from_end, from_next, to, to + 1, to_next)
 ```
+shall also return `ok`.[^8]
+[*Note 1*: As a result of operations on `state`, it can return `ok` or
+`partial` and set `from_next == from` and
+`to_next != to`. — *end note*]
+*Remarks:* Its operations on `state` are unspecified.
+[*Note 2*: This argument can be used, for example, to maintain shift
+state, to specify conversion options (such as count only), or to
+identify a cache of seek offsets. — *end note*]
 *Returns:* An enumeration value, as summarized in
 Table  [[tab:localization.convert.result.values.out.in]].
 **Table: `do_in/do_out` result values** <a id="tab:localization.convert.result.values.out.in">[tab:localization.convert.result.values.out.in]</a>
 | Value     | Meaning                                                                                          |
 | --------- | ------------------------------------------------------------------------------------------------ |
 | `ok`      | completed the conversion                                                                         |
 | `partial` | not all source characters converted                                                              |
+| `error`   | encountered a character in {[}`from`, `from_end`{)} that it could not convert |
 | `noconv`  | `internT` and `externT` are the same type, and input sequence is identical to converted sequence |
+A return value of `partial`, if `(from_next == from_end)`, indicates
+that either the destination sequence has not absorbed all the available
 destination elements, or that additional source elements are needed
 before another destination element can be produced.
 ``` cpp
+result do_unshift(stateT& state, externT* to, externT* to_end, externT*& to_next) const;
 ```
+*Requires:* `(to <= to_end)` well defined and `true`; state initialized,
 if at the beginning of a sequence, or else equal to the result of
 converting the preceding characters in the sequence.
 *Effects:* Places characters starting at `to` that should be appended to
+terminate a sequence when the current `stateT` is given by `state`.[^9]
 Stores no more than `(to_end - to)` destination elements, and leaves the
 `to_next` pointer pointing one beyond the last element successfully
 stored.
 *Returns:* An enumeration value, as summarized in
 Table  [[tab:localization.convert.result.values.unshift]].
 **Table: `do_unshift` result values** <a id="tab:localization.convert.result.values.unshift">[tab:localization.convert.result.values.unshift]</a>
 | Value     | Meaning                                                                                                              |
+| --------- | -------------------------------------------------------------------------------------------------------------------- |
 | `ok`      | completed the sequence                                                                                               |
 | `partial` | space for more than `to_end - to` destination elements was needed to terminate a sequence given the value of `state` |
 | `error`   | an unspecified error has occurred                                                                                    |
 | `noconv`  | no termination is needed for this `state_type`                                                                       |
 ``` cpp
 int do_encoding() const noexcept;
 ```
+*Returns:* `-1` if the encoding of the `externT` sequence is
 state-dependent; else the constant number of `externT` characters needed
+to produce an internal character; or `0` if this number is not a
+constant.[^10]
 ``` cpp
 bool do_always_noconv() const noexcept;
 ```
 *Returns:* `true` if `do_in()` and `do_out()` return `noconv` for all
 valid argument values. `codecvt<char, char, mbstate_t>` returns `true`.
 ``` cpp
+int do_length(stateT& state, const externT* from, const externT* from_end, size_t max) const;
 ```
+*Requires:* `(from <= from_end)` well-defined and `true`; `state`
 initialized, if at the beginning of a sequence, or else equal to the
 result of converting the preceding characters in the sequence.
 *Effects:* The effect on the `state` argument is “as if” it called
 `do_in(state, from, from_end, from, to, to+max, to)` for `to` pointing
 to a buffer of at least `max` elements.
 *Returns:* `(from_next-from)` where `from_next` is the largest value in
+the range \[`from`, `from_end`\] such that the sequence of values in the
 range \[`from`, `from_next`) represents `max` or fewer valid complete
 characters of type `internT`. The specialization
 `codecvt<char, char, mbstate_t>`, returns the lesser of `max` and
 `(from_end-from)`.
 ``` cpp
 int do_max_length() const noexcept;
 ```
 *Returns:* The maximum value that `do_length(state, from, from_end, 1)`
+can return for any valid range \[`from`, `from_end`) and `stateT` value
 `state`. The specialization
 `codecvt<char, char, mbstate_t>::do_max_length()` returns 1.
 #### Class template `codecvt_byname` <a id="locale.codecvt.byname">[[locale.codecvt.byname]]</a>
 ### The numeric category <a id="category.numeric">[[category.numeric]]</a>
 The classes `num_get<>` and `num_put<>` handle numeric formatting and
 parsing. Virtual functions are provided for several numeric types.
 Implementations may (but are not required to) delegate extraction of
+smaller types to extractors for larger types.[^11]
 All specifications of member functions for `num_put` and `num_get` in
 the subclauses of  [[category.numeric]] only apply to the
 specializations required in Tables  [[tab:localization.category.facets]]
 and  [[tab:localization.required.specializations]] (
 ``` cpp
 namespace std {
   template <class charT, class InputIterator = istreambuf_iterator<charT>>
     class num_get : public locale::facet {
     public:
+      using char_type = charT;
+      using iter_type = InputIterator;
       explicit num_get(size_t refs = 0);
       iter_type get(iter_type in, iter_type end, ios_base&,
                     ios_base::iostate& err, bool& v) const;
 | `double`             | `l`             |
 | `long double`        | `L`             |
 - **Stage 2:**
+If `in == end` then stage 2 terminates. Otherwise a `charT` is taken
+from `in` and local variables are initialized as if by
 ``` cpp
 char_type ct = *in;
 char c = src[find(atoms, atoms + sizeof(src) - 1, ct) - atoms];
 if (ct == use_facet<numpunct<charT>>(loc).decimal_point())
 use_facet<ctype<charT>>(loc).widen(src, src + sizeof(src), atoms);
 ```
 for this value of `loc`.
+If `discard` is `true`, then if `’.’` has not yet been accumulated, then
 the position of the character is remembered, but the character is
 otherwise ignored. Otherwise, if `’.’` has already been accumulated, the
 character is discarded and Stage 2 terminates. If it is not discarded,
 then a check is made to determine if `c` is allowed as the next
 character of an input field of the conversion specifier returned by
 - For a signed integer value, the function `strtoll`.
 - For an unsigned integer value, the function `strtoull`.
+- For a `float` value, the function `strtof`.
+- For a `double` value, the function `strtod`.
+- For a `long double` value, the function `strtold`.
 The numeric value to be stored can be one of:
+- zero, if the conversion function does not convert the entire field.
+- the most positive (or negative) representable value, if the field to
+ be converted to a signed integer type represents a value too large
+ positive (or negative) to be represented in `val`.
+- the most positive representable value, if the field to be converted to
+ an unsigned integer type represents a value that cannot be represented
+  in `val`.
 - the converted value, otherwise.
+The resultant numeric value is stored in `val`. If the conversion
+function does not convert the entire field, or if the field represents a
+value outside the range of representable values, `ios_base::failbit` is
+assigned to `err`.
 Digit grouping is checked. That is, the positions of discarded
 separators is examined for consistency with
+`use_facet<numpunct<charT>>(loc).grouping()`. If they are not consistent
+then `ios_base::failbit` is assigned to `err`.
 In any case, if stage 2 processing was terminated by the test for
 `in == end` then `err |= ios_base::eofbit` is performed.
 ``` cpp
 iter_type do_get(iter_type in, iter_type end, ios_base& str,
                  ios_base::iostate& err, bool& val) const;
 ```
+*Effects:* If `(str.flags()&ios_base::boolalpha) == 0` then input
 proceeds as it would for a `long` except that if a value is being stored
 into `val`, the value is determined according to the following: If the
+value to be stored is 0 then `false` is stored. If the value is `1` then
 `true` is stored. Otherwise `true` is stored and `ios_base::failbit` is
 assigned to `err`.
 Otherwise target sequences are determined “as if” by calling the members
 `falsename()` and `truename()` of the facet obtained by
+`use_facet<numpunct<charT>>(str.getloc())`. Successive characters in the
+range \[`in`, `end`) (see  [[sequence.reqmts]]) are obtained and matched
+against corresponding positions in the target sequences only as
 necessary to identify a unique match. The input iterator `in` is
 compared to `end` only when necessary to obtain a character. If a target
 sequence is uniquely matched, `val` is set to the corresponding value.
 Otherwise `false` is stored and `ios_base::failbit` is assigned to
 `err`.
 The `in` iterator is always left pointing one position beyond the last
 character successfully matched. If `val` is set, then `err` is set to
 `str.goodbit`; or to `str.eofbit` if, when seeking another character to
 match, it is found that `(in == end)`. If `val` is not set, then `err`
 is set to `str.failbit`; or to `(str.failbit|str.eofbit)` if the reason
+for the failure was that `(in == end)`.
+[*Example 1*: For targets `true`: `"a"` and `false`: `"abb"`, the input
+sequence `"a"` yields `val == true` and `err == str.eofbit`; the input
+sequence `"abc"` yields `err = str.failbit`, with `in` ending at the
+`’c’` element. For targets `true`: `"1"` and `false`: `"0"`, the input
+sequence `"1"` yields `val == true` and `err == str.goodbit`. For empty
+targets `("")`, any input sequence yields
+`err == str.failbit`. — *end example*]
 *Returns:* `in`.
 #### Class template `num_put` <a id="locale.nm.put">[[locale.nm.put]]</a>
 ``` cpp
 namespace std {
   template <class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class num_put : public locale::facet {
     public:
+      using char_type = charT;
+      using iter_type = OutputIterator;
       explicit num_put(size_t refs = 0);
       iter_type put(iter_type s, ios_base& f, char_type fill, bool v) const;
       iter_type put(iter_type s, ios_base& f, char_type fill, long v) const;
       iter_type put(iter_type s, ios_base& f, char_type fill, long long v) const;
+ iter_type put(iter_type s, ios_base& f, char_type fill, unsigned long v) const;
+      iter_type put(iter_type s, ios_base& f, char_type fill, unsigned long long v) const;
+ iter_type put(iter_type s, ios_base& f, char_type fill, double v) const;
+      iter_type put(iter_type s, ios_base& f, char_type fill, long double v) const;
+ iter_type put(iter_type s, ios_base& f, char_type fill, const void* v) const;
       static locale::id id;
     protected:
       ~num_put();
+ virtual iter_type do_put(iter_type, ios_base&, char_type fill, bool v) const;
+      virtual iter_type do_put(iter_type, ios_base&, char_type fill, long v) const;
+ virtual iter_type do_put(iter_type, ios_base&, char_type fill, long long v) const;
+      virtual iter_type do_put(iter_type, ios_base&, char_type fill, unsigned long) const;
+ virtual iter_type do_put(iter_type, ios_base&, char_type fill, unsigned long long) const;
+      virtual iter_type do_put(iter_type, ios_base&, char_type fill, double v) const;
+ virtual iter_type do_put(iter_type, ios_base&, char_type fill, long double v) const;
+      virtual iter_type do_put(iter_type, ios_base&, char_type fill, const void* v) const;
     };
 }
 ```
 The facet `num_put` is used to format numeric values to a character
 sequence such as an ostream.
 ##### `num_put` members <a id="facet.num.put.members">[[facet.num.put.members]]</a>
 ``` cpp
+iter_type put(iter_type out, ios_base& str, char_type fill, bool val) const;
+iter_type put(iter_type out, ios_base& str, char_type fill, long val) const;
+iter_type put(iter_type out, ios_base& str, char_type fill, long long val) const;
+iter_type put(iter_type out, ios_base& str, char_type fill, unsigned long val) const;
+iter_type put(iter_type out, ios_base& str, char_type fill, unsigned long long val) const;
+iter_type put(iter_type out, ios_base& str, char_type fill, double val) const;
+iter_type put(iter_type out, ios_base& str, char_type fill, long double val) const;
+iter_type put(iter_type out, ios_base& str, char_type fill, const void* val) const;
 ```
 *Returns:* `do_put(out, str, fill, val)`.
 ##### `num_put` virtual functions <a id="facet.num.put.virtuals">[[facet.num.put.virtuals]]</a>
 ``` cpp
+iter_type do_put(iter_type out, ios_base& str, char_type fill, long val) const;
+iter_type do_put(iter_type out, ios_base& str, char_type fill, long long val) const;
+iter_type do_put(iter_type out, ios_base& str, char_type fill, unsigned long val) const;
+iter_type do_put(iter_type out, ios_base& str, char_type fill, unsigned long long val) const;
+iter_type do_put(iter_type out, ios_base& str, char_type fill, double val) const;
+iter_type do_put(iter_type out, ios_base& str, char_type fill, long double val) const;
+iter_type do_put(iter_type out, ios_base& str, char_type fill, const void* val) const;
 ```
 *Effects:* Writes characters to the sequence `out`, formatting `val` as
+desired. In the following description, a local variable initialized
+with:
 ``` cpp
 locale loc = str.getloc();
 ```
 The details of this operation occur in several stages:
+- Stage 1: Determine a printf conversion specifier `spec` and determine
+  the characters that would be printed by `printf` ([[c.files]]) given
+  this conversion specifier for
   ``` cpp
   printf(spec, val)
   ```
   assuming that the current locale is the `"C"` locale.
 fmtflags basefield =  (flags & (ios_base::basefield));
 fmtflags uppercase =  (flags & (ios_base::uppercase));
 fmtflags floatfield = (flags & (ios_base::floatfield));
 fmtflags showpos =    (flags & (ios_base::showpos));
 fmtflags showbase =   (flags & (ios_base::showbase));
+fmtflags showpoint =  (flags & (ios_base::showpoint));
 ```
 All tables used in describing stage 1 are ordered. That is, the first
 line whose condition is true applies. A line without a condition is the
 default behavior when none of the earlier lines apply.
 Table [[tab:localization.numeric.conversions]].
 **Table: Numeric conversions** <a id="tab:localization.numeric.conversions">[tab:localization.numeric.conversions]</a>
 | Type(s)               | State       | `stdio` equivalent |
+| --------------------- | ----------- | ------------------ |
+| an integral type      | `showpos`   | `+`                |
+|                       | `showbase`  | `#`                |
+| a floating-point type | `showpos`   | `+`                |
+|                       | `showpoint` | `#`                |
 For conversion from a floating-point type, if
 `floatfield != (ios_base::fixed | ios_base::scientific)`,
 `str.precision()` is specified as precision in the conversion
 ``` cpp
 fmtflags adjustfield = (flags & (ios_base::adjustfield));
 ```
+The location of any padding[^12] is determined according to
 Table [[tab:localization.fill.padding]].
 **Table: Fill padding** <a id="tab:localization.fill.padding">[tab:localization.fill.padding]</a>
 | State                                                                          | Location           |
 ``` cpp
 *out++ = c
 ```
 ``` cpp
+iter_type do_put(iter_type out, ios_base& str, char_type fill, bool val) const;
 ```
 *Returns:* If `(str.flags() & ios_base::boolalpha) == 0` returns
 `do_put(out, str, fill,`
 `(int)val)`, otherwise obtains a string `s` as if by
 ``` cpp
 namespace std {
   template <class charT>
     class numpunct : public locale::facet {
     public:
+      using char_type   = charT;
+      using string_type = basic_string<charT>;
       explicit numpunct(size_t refs = 0);
       char_type    decimal_point()   const;
       char_type    thousands_sep()   const;
 ``` cpp
 char_type decimal_point() const;
 ```
+*Returns:* `do_decimal_point()`.
 ``` cpp
 char_type thousands_sep() const;
 ```
+*Returns:* `do_thousands_sep()`.
 ``` cpp
 string grouping()  const;
 ```
+*Returns:* `do_grouping()`.
 ``` cpp
 string_type truename()  const;
 string_type falsename() const;
 ```
 string do_grouping() const;
 ```
 *Returns:* A basic_string\<char\> `vec` used as a vector of integer
 values, in which each element `vec[i]` represents the number of
+digits[^13] in the group at position `i`, starting with position 0 as
 the rightmost group. If `vec.size() <= i`, the number is the same as
+group `(i - 1)`; if `(i < 0 || vec[i] <= 0 || vec[i] == CHAR_MAX)`, the
+size of the digit group is unlimited.
 The required specializations return the empty string, indicating no
 grouping.
 ``` cpp
 namespace std {
   template <class charT>
   class numpunct_byname : public numpunct<charT> {
   // this class is specialized for char and wchar_t.
   public:
+ using char_type   = charT;
+ using string_type = basic_string<charT>;
     explicit numpunct_byname(const char*, size_t refs = 0);
     explicit numpunct_byname(const string&, size_t refs = 0);
   protected:
     ~numpunct_byname();
   };
 ``` cpp
 namespace std {
   template <class charT>
     class collate : public locale::facet {
     public:
+      using char_type   = charT;
+      using string_type = basic_string<charT>;
       explicit collate(size_t refs = 0);
       int compare(const charT* low1, const charT* high1,
                   const charT* low2, const charT* high2) const;
 ``` cpp
 int compare(const charT* low1, const charT* high1,
             const charT* low2, const charT* high2) const;
 ```
+*Returns:* `do_compare(low1, high1, low2, high2)`.
 ``` cpp
 string_type transform(const charT* low, const charT* high) const;
 ```
+*Returns:* `do_transform(low, high)`.
 ``` cpp
 long hash(const charT* low, const charT* high) const;
 ```
+*Returns:* `do_hash(low, high)`.
 ##### `collate` virtual functions <a id="locale.collate.virtuals">[[locale.collate.virtuals]]</a>
 ``` cpp
 int do_compare(const charT* low1, const charT* high1,
 ```
 *Returns:* A `basic_string<charT>` value that, compared
 lexicographically with the result of calling `transform()` on another
 string, yields the same result as calling `do_compare()` on the same two
+strings.[^14]
 ``` cpp
 long do_hash(const charT* low, const charT* high) const;
 ```
 *Returns:* An integer value equal to the result of calling `hash()` on
 any other string for which `do_compare()` returns 0 (equal) when passed
+the two strings.
+[*Note 1*: The probability that the result equals that for another
 string which does not compare equal should be very small, approaching
+`(1.0/numeric_limits<unsigned long>::max())`. — *end note*]
 #### Class template `collate_byname` <a id="locale.collate.byname">[[locale.collate.byname]]</a>
 ``` cpp
 namespace std {
   template <class charT>
     class collate_byname : public collate<charT> {
     public:
+      using string_type = basic_string<charT>;
       explicit collate_byname(const char*, size_t refs = 0);
       explicit collate_byname(const string&, size_t refs = 0);
     protected:
       ~collate_byname();
     };
 parsing. All specifications of member functions for `time_put` and
 `time_get` in the subclauses of  [[category.time]] only apply to the
 specializations required in Tables  [[tab:localization.category.facets]]
 and  [[tab:localization.required.specializations]] (
 [[locale.category]]). Their members use their `ios_base&`,
+`ios_base::iostate&`, and `fill` arguments as described in
+[[locale.categories]], and the `ctype<>` facet, to determine formatting
 details.
 #### Class template `time_get` <a id="locale.time.get">[[locale.time.get]]</a>
 ``` cpp
   };
   template <class charT, class InputIterator = istreambuf_iterator<charT>>
     class time_get : public locale::facet, public time_base {
     public:
+      using char_type = charT;
+      using iter_type = InputIterator;
       explicit time_get(size_t refs = 0);
       dateorder date_order()  const { return do_date_order(); }
       iter_type get_time(iter_type s, iter_type end, ios_base& f,
 ```
 `time_get`
 is used to parse a character sequence, extracting components of a time
+or date into a `struct tm` object. Each `get` member parses a format as
 produced by a corresponding format specifier to `time_put<>::put`. If
 the sequence being parsed matches the correct format, the corresponding
 members of the `struct tm` argument are set to the values used to
 produce the sequence; otherwise either an error is reported or
+unspecified values are assigned.[^15]
 If the end iterator is reached during parsing by any of the `get()`
 member functions, the member sets `ios_base::eofbit` in `err`.
 ##### `time_get` members <a id="locale.time.get.members">[[locale.time.get.members]]</a>
 ``` cpp
 dateorder date_order() const;
 ```
+*Returns:* `do_date_order()`.
 ``` cpp
 iter_type get_time(iter_type s, iter_type end, ios_base& str,
                    ios_base::iostate& err, tm* t) const;
 ```
+*Returns:* `do_get_time(s, end, str, err, t)`.
 ``` cpp
 iter_type get_date(iter_type s, iter_type end, ios_base& str,
                    ios_base::iostate& err, tm* t) const;
 ```
+*Returns:* `do_get_date(s, end, str, err, t)`.
 ``` cpp
 iter_type get_weekday(iter_type s, iter_type end, ios_base& str,
                       ios_base::iostate& err, tm* t) const;
 iter_type get_monthname(iter_type s, iter_type end, ios_base& str,
                         ios_base::iostate& err, tm* t) const;
 ```
 *Returns:* `do_get_weekday(s, end, str, err, t)` or
+`do_get_monthname(s, end, str, err, t)`.
 ``` cpp
 iter_type get_year(iter_type s, iter_type end, ios_base& str,
                    ios_base::iostate& err, tm* t) const;
 ```
+*Returns:* `do_get_year(s, end, str, err, t)`.
 ``` cpp
+iter_type get(iter_type s, iter_type end, ios_base& f, ios_base::iostate& err,
+ tm* t, char format, char modifier = 0) const;
 ```
+*Returns:* `do_get(s, end, f, err, t, format, modifier)`.
 ``` cpp
+iter_type get(iter_type s, iter_type end, ios_base& f, ios_base::iostate& err,
+ tm* t, const char_type* fmt, const char_type* fmtend) const;
 ```
 *Requires:* \[`fmt`, `fmtend`) shall be a valid range.
 *Effects:* The function starts by evaluating `err = ios_base::goodbit`.
 It then enters a loop, reading zero or more characters from `s` at each
 iteration. Unless otherwise specified below, the loop terminates when
 the first of the following conditions holds:
+- The expression `fmt == fmtend` evaluates to `true`.
+- The expression `err == ios_base::goodbit` evaluates to `false`.
+- The expression `s == end` evaluates to `true`, in which case the
   function evaluates `err = ios_base::eofbit | ios_base::failbit`.
 - The next element of `fmt` is equal to `’%’`, optionally followed by a
   modifier character, followed by a conversion specifier character,
   `format`, together forming a conversion specification valid for the
   ISO/IEC 9945 function `strptime`. If the number of elements in the
   value of `modifier` is `’\0’` when the optional modifier is absent
   from the conversion specification. If `err == ios_base::goodbit` holds
   after the evaluation of the expression, the function increments `fmt`
   to point just past the end of the conversion specification and
   continues looping.
+- The expression `isspace(*fmt, f.getloc())` evaluates to `true`, in
+ which case the function first increments `fmt` until
+  `fmt == fmtend || !isspace(*fmt, f.getloc())` evaluates to `true`,
+ then advances `s` until `s == end || !isspace(*s, f.getloc())` is
+ `true`, and finally resumes looping.
 - The next character read from `s` matches the element pointed to by
   `fmt` in a case-insensitive comparison, in which case the function
   evaluates `++fmt, ++s` and continues looping. Otherwise, the function
   evaluates `err = ios_base::failbit`.
+[*Note 1*: The function uses the `ctype<charT>` facet installed in
+`f`’s locale to determine valid whitespace characters. It is unspecified
+by what means the function performs case-insensitive comparison or
+whether multi-character sequences are considered while doing
+so. — *end note*]
+*Returns:* `s`.
 ##### `time_get` virtual functions <a id="locale.time.get.virtuals">[[locale.time.get.virtuals]]</a>
 ``` cpp
 dateorder do_date_order() const;
 ```
 *Returns:* An enumeration value indicating the preferred order of
 components for those date formats that are composed of day, month, and
+year.[^16] Returns `no_order` if the date format specified by `’x’`
 contains other variable components (e.g., Julian day, week number, week
 day).
 ``` cpp
 iter_type do_get_time(iter_type s, iter_type end, ios_base& str,
 appropriate for the ISO/IEC 9945 function `strptime`, formed by
 concatenating `’%’`, the `modifier` character, when non-NUL, and the
 `format` character. When the concatenation fails to yield a complete
 valid directive the function leaves the object pointed to by `t`
 unchanged and evaluates `err |= ios_base::failbit`. When `s == end`
+evaluates to `true` after reading a character the function evaluates
 `err |= ios_base::eofbit`.
 For complex conversion directives such as `%c`, `%x`, or `%X`, or
 directives that involve the optional modifiers `E` or `O`, when the
 function is unable to unambiguously determine some or all `struct tm`
 members from the input sequence \[`s`, `end`), it evaluates
 `err |= ios_base::eofbit`. In such cases the values of those `struct tm`
 members are unspecified and may be outside their valid range.
+*Remarks:* It is unspecified whether multiple calls to `do_get()` with
+the address of the same `struct tm` object will update the current
+contents of the object or simply overwrite its members. Portable
+programs must zero out the object before invoking the function.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as possibly part of a valid input sequence for the given
 `format` and `modifier`.
 ``` cpp
 namespace std {
   template <class charT, class InputIterator = istreambuf_iterator<charT>>
   class time_get_byname : public time_get<charT, InputIterator> {
   public:
+ using dateorder = time_base::dateorder;
+ using iter_type = InputIterator;
     explicit time_get_byname(const char*, size_t refs = 0);
     explicit time_get_byname(const string&, size_t refs = 0);
   protected:
     ~time_get_byname();
 ``` cpp
 namespace std {
   template <class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class time_put : public locale::facet {
     public:
+      using char_type = charT;
+      using iter_type = OutputIterator;
       explicit time_put(size_t refs = 0);
       // the following is implemented in terms of other member functions.
       iter_type put(iter_type s, ios_base& f, char_type fill, const tm* tmb,
 interleaved in the output in the order in which they appear in the
 pattern. Format sequences are identified by converting each character
 `c` to a `char` value as if by `ct.narrow(c, 0)`, where `ct` is a
 reference to `ctype<charT>` obtained from `str.getloc()`. The first
 character of each sequence is equal to `’%’`, followed by an optional
+modifier character `mod`[^17] and a format specifier character `spec` as
 defined for the function `strftime`. If no modifier character is
 present, `mod` is zero. For each valid format sequence identified, calls
 `do_put(s, str, fill, t, spec, mod)`.
 The second form calls `do_put(s, str, fill, t, format, modifier)`.
+[*Note 1*: The `fill` argument may be used in the
+implementation-defined formats or by derivations. A space character is a
+reasonable default for this argument. — *end note*]
 *Returns:* An iterator pointing immediately after the last character
 produced.
 ##### `time_put` virtual functions <a id="locale.time.put.virtuals">[[locale.time.put.virtuals]]</a>
 *Effects:* Formats the contents of the parameter `t` into characters
 placed on the output sequence `s`. Formatting is controlled by the
 parameters `format` and `modifier`, interpreted identically as the
 format specifiers in the string argument to the standard library
+function `strftime()`[^18], except that the sequence of characters
 produced for those specifiers that are described as depending on the C
+locale are instead *implementation-defined*.[^19]
 *Returns:* An iterator pointing immediately after the last character
+produced.
+[*Note 2*: The `fill` argument may be used in the
+implementation-defined formats or by derivations. A space character is a
+reasonable default for this argument. — *end note*]
 #### Class template `time_put_byname` <a id="locale.time.put.byname">[[locale.time.put.byname]]</a>
 ``` cpp
 namespace std {
   template <class charT, class OutputIterator = ostreambuf_iterator<charT>>
   class time_put_byname : public time_put<charT, OutputIterator>
   {
   public:
+ using char_type = charT;
+ using iter_type = OutputIterator;
     explicit time_put_byname(const char*, size_t refs = 0);
     explicit time_put_byname(const string&, size_t refs = 0);
   protected:
     ~time_put_byname();
 All specifications of member functions for `money_put` and `money_get`
 in the subclauses of  [[category.monetary]] only apply to the
 specializations required in Tables  [[tab:localization.category.facets]]
 and  [[tab:localization.required.specializations]] (
 [[locale.category]]). Their members use their `ios_base&`,
+`ios_base::iostate&`, and `fill` arguments as described in
+[[locale.categories]], and the `moneypunct<>` and `ctype<>` facets, to
 determine formatting details.
 #### Class template `money_get` <a id="locale.money.get">[[locale.money.get]]</a>
 ``` cpp
 namespace std {
+  template <class charT, class InputIterator = istreambuf_iterator<charT>>
     class money_get : public locale::facet {
     public:
+      using char_type   = charT;
+      using iter_type   = InputIterator;
+      using string_type = basic_string<charT>;
       explicit money_get(size_t refs = 0);
       iter_type get(iter_type s, iter_type end, bool intl,
                     ios_base& f, ios_base::iostate& err,
               long double& quant) const;
 iter_type get(s, iter_type end, bool intl, ios_base&f,
               ios_base::iostate& err, string_type& quant) const;
 ```
+*Returns:* `do_get(s, end, intl, f, err, quant)`.
 ##### `money_get` virtual functions <a id="locale.money.get.virtuals">[[locale.money.get.virtuals]]</a>
 ``` cpp
 iter_type do_get(iter_type s, iter_type end, bool intl,
 does not change `units` or `digits`. Uses the pattern returned by
 `mp.neg_format()` to parse all values. The result is returned as an
 integral value stored in `units` or as a sequence of digits possibly
 preceded by a minus sign (as produced by `ct.widen(c)` where `c` is
 `’-’` or in the range from `’0’` through `’9’`, inclusive) stored in
+`digits`.
+[*Example 1*: The sequence `$1,056.23` in a common United States locale
+would yield, for `units`, `105623`, or, for `digits`,
+`"105623"`. — *end example*]
+If `mp.grouping()` indicates that no thousands separators are permitted,
 any such characters are not read, and parsing is terminated at the point
 where they first appear. Otherwise, thousands separators are optional;
 if present, they are checked for correct placement only after all format
 components have been read.
 If the first character (if any) in the string `pos` returned by
 `mp.positive_sign()` or the string `neg` returned by
 `mp.negative_sign()` is recognized in the position indicated by `sign`
 in the format pattern, it is consumed and any remaining characters in
+the string are required after all the other format components.
+[*Example 2*: If `showbase` is off, then for a `neg` value of `"()"`
+and a currency symbol of `"L"`, in `"(100 L)"` the `"L"` is consumed;
+but if `neg` is `"-"`, the `"L"` in `"-100 L"` is not
+consumed. — *end example*]
+If `pos` or `neg` is empty, the sign component is optional, and if no
+sign is detected, the result is given the sign that corresponds to the
+source of the empty string. Otherwise, the character in the indicated
+position must match the first character of `pos` or `neg`, and the
+result is given the corresponding sign. If the first character of `pos`
+is equal to the first character of `neg`, or if both strings are empty,
+the result is given a positive sign.
 Digits in the numeric monetary component are extracted and placed in
 `digits`, or into a character buffer `buf1` for conversion to produce a
 value for `units`, in the order in which they appear, preceded by a
 minus sign if and only if the result is negative. The value `units` is
+produced as if by[^20]
 ``` cpp
 for (int i = 0; i < n; ++i)
   buf2[i] = src[find(atoms, atoms+sizeof(src), buf1[i]) - atoms];
 buf2[n] = 0;
 #### Class template `money_put` <a id="locale.money.put">[[locale.money.put]]</a>
 ``` cpp
 namespace std {
+  template <class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class money_put : public locale::facet {
     public:
+      using char_type   = charT;
+ using iter_type   = OutputIterator;
+      using string_type = basic_string<charT>;
       explicit money_put(size_t refs = 0);
       iter_type put(iter_type s, bool intl, ios_base& f,
                     char_type fill, long double units) const;
               long double quant) const;
 iter_type put(iter_type s, bool intl, ios_base& f, char_type fill,
               const string_type& quant) const;
 ```
+*Returns:* `do_put(s, intl, f, loc, quant)`.
 ##### `money_put` virtual functions <a id="locale.money.put.virtuals">[[locale.money.put.virtuals]]</a>
 ``` cpp
 iter_type do_put(iter_type s, bool intl, ios_base& str,
 `(str.flags() & str.showbase)` is nonzero. If the number of characters
 generated for the specified format is less than the value returned by
 `str.width()` on entry to the function, then copies of `fill` are
 inserted as necessary to pad to the specified width. For the value `af`
 equal to `(str.flags() & str.adjustfield)`, if `(af == str.internal)` is
+`true`, the fill characters are placed where `none` or `space` appears
+in the formatting pattern; otherwise if `(af == str.left)` is `true`,
+they are placed after the other characters; otherwise, they are placed
+before the other characters.
+[*Note 1*: It is possible, with some combinations of format patterns
+and flag values, to produce output that cannot be parsed using
+`num_get<>::get`. — *end note*]
 *Returns:* An iterator pointing immediately after the last character
 produced.
 #### Class template `moneypunct` <a id="locale.moneypunct">[[locale.moneypunct]]</a>
   };
   template <class charT, bool International = false>
     class moneypunct : public locale::facet, public money_base {
     public:
+      using char_type   = charT;
+      using string_type = basic_string<charT>;
       explicit moneypunct(size_t refs = 0);
       charT        decimal_point() const;
       charT        thousands_sep() const;
 The `moneypunct<>` facet defines monetary formatting parameters used by
 `money_get<>` and `money_put<>`. A monetary format is a sequence of four
 components, specified by a `pattern` value `p`, such that the `part`
 value `static_cast<part>(p.field[i])` determines the `i`th component of
+the format[^21] In the `field` member of a `pattern` object, each value
 `symbol`, `sign`, `value`, and either `space` or `none` appears exactly
 once. The value `none`, if present, is not first; the value `space`, if
 present, is neither first nor last.
 Where `none` or `space` appears, white space is permitted in the format,
 pattern      pos_format()    const;
 pattern      neg_format()    const;
 ```
 Each of these functions `F` returns the result of calling the
+corresponding virtual member function `do_F()`.
 ##### `moneypunct` virtual functions <a id="locale.moneypunct.virtuals">[[locale.moneypunct.virtuals]]</a>
 ``` cpp
 charT do_decimal_point() const;
 ```
 *Returns:* The radix separator to use in case `do_frac_digits()` is
+greater than zero.[^22]
 ``` cpp
 charT do_thousands_sep() const;
 ```
 *Returns:* The digit group separator to use in case `do_grouping()`
+specifies a digit grouping pattern.[^23]
 ``` cpp
 string do_grouping() const;
 ```
 *Returns:* A pattern defined identically as, but not necessarily equal
+to, the result of `numpunct<charT>::do_grouping()`.[^24]
 ``` cpp
 string_type do_curr_symbol() const;
 ```
+*Returns:* A string to use as the currency identifier symbol.[^25]
 ``` cpp
 string_type do_positive_sign() const;
 string_type do_negative_sign() const;
 ```
 *Returns:* `do_positive_sign()` returns the string to use to indicate a
+positive monetary value;[^26] `do_negative_sign()` returns the string to
 use to indicate a negative value.
 ``` cpp
 int do_frac_digits() const;
 ```
 *Returns:* The number of digits after the decimal radix separator, if
+any.[^27]
 ``` cpp
 pattern do_pos_format() const;
 pattern do_neg_format() const;
 ```
 *Returns:* The specializations required in
 Table  [[tab:localization.required.specializations]] ([[locale.category]]),
 namely `moneypunct<char>`, `moneypunct<wchar_t>`,
 `moneypunct<char, true>`, and `moneypunct<wchar_t, true>`, return an
 object of type `pattern` initialized to
+`{ symbol, sign, none, value }`.[^28]
 #### Class template `moneypunct_byname` <a id="locale.moneypunct.byname">[[locale.moneypunct.byname]]</a>
 ``` cpp
 namespace std {
   template <class charT, bool Intl = false>
   class moneypunct_byname : public moneypunct<charT, Intl> {
   public:
+ using pattern     = money_base::pattern;
+ using string_type = basic_string<charT>;
     explicit moneypunct_byname(const char*, size_t refs = 0);
     explicit moneypunct_byname(const string&, size_t refs = 0);
   protected:
     ~moneypunct_byname();
 ``` cpp
 namespace std {
   class messages_base {
   public:
+ using catalog = unspecified signed integer type;
   };
   template <class charT>
     class messages : public locale::facet, public messages_base {
     public:
+      using char_type   = charT;
+      using string_type = basic_string<charT>;
       explicit messages(size_t refs = 0);
       catalog open(const basic_string<char>& fn, const locale&) const;
       string_type get(catalog c, int set, int msgid,
 ```
 *Returns:* `do_open(name, loc)`.
 ``` cpp
+string_type get(catalog cat, int set, int msgid, const string_type& dfault) const;
 ```
 *Returns:* `do_get(cat, set, msgid, dfault)`.
 ``` cpp
 *Effects:* Calls `do_close(cat)`.
 ##### `messages` virtual functions <a id="locale.messages.virtuals">[[locale.messages.virtuals]]</a>
 ``` cpp
+catalog do_open(const basic_string<char>& name, const locale& loc) const;
 ```
 *Returns:* A value that may be passed to `get()` to retrieve a message
 from the message catalog identified by the string `name` according to an
 *implementation-defined* mapping. The result can be used until it is
 *Remarks:* The locale argument `loc` is used for character set code
 conversion when retrieving messages, if needed.
 ``` cpp
+string_type do_get(catalog cat, int set, int msgid, const string_type& dfault) const;
 ```
 *Requires:* `cat` shall be a catalog obtained from `open()` and not yet
 closed.
 closed.
 *Effects:* Releases unspecified resources associated with `cat`.
 *Remarks:* The limit on such resources, if any, is
+*implementation-defined*.
 #### Class template `messages_byname` <a id="locale.messages.byname">[[locale.messages.byname]]</a>
 ``` cpp
 namespace std {
   template <class charT>
   class messages_byname : public messages<charT> {
   public:
+ using catalog     = messages_base::catalog;
+ using string_type = basic_string<charT>;
     explicit messages_byname(const char*, size_t refs = 0);
     explicit messages_byname(const string&, size_t refs = 0);
   protected:
     ~messages_byname();
 A C++program may define facets to be added to a locale and used
 identically as the built-in facets. To create a new facet interface,
 C++programs simply derive from `locale::facet` a class containing a
 static member: `static locale::id id`.
+[*Note 1*: The locale member function templates verify its type and
+storage class. — *end note*]
+[*Example 1*:
 Traditional global localization is still easy:
 ``` cpp
 #include <iostream>
   return MyObject(argc, argv).doit();
 }
 ```
+— *end example*]
+[*Example 2*:
 Greater flexibility is possible:
 ``` cpp
 #include <iostream>
 #include <locale>
 }
 ```
 In a European locale, with input `3.456,78`, output is `3456.78`.
+— *end example*]
 This can be important even for simple programs, which may need to write
 a data file in a fixed format, regardless of a user’s preference.
+[*Example 3*:
 Here is an example of the use of locales in a library interface.
 ``` cpp
 // file: Date.h
 #include <iosfwd>
   }
   return s;
 }
 ```
+— *end example*]
 A locale object may be extended with a new facet simply by constructing
 it with an instance of a class derived from `locale::facet`. The only
 member a C++program must define is the static member `id`, which
 identifies your class interface as a new facet.
+[*Example 4*:
 Classifying Japanese characters:
 ``` cpp
 // file: <jctype>
 #include <locale>
 #include "jctype"               // above
 std::locale::id My::JCtype::id; // the static JCtype member declared above.
 int main() {
   using namespace std;
+ using wctype = ctype<wchar_t>;
   locale loc(locale(""),        // the user's preferred locale ...
          new My::JCtype);       // and a new feature ...
   wchar_t c = use_facet<wctype>(loc).widen('!');
   if (!use_facet<My::JCtype>(loc).is_kanji(c))
     cout << "no it isn't!" << endl;
 }
 ```
 The new facet is used exactly like the built-in facets.
+— *end example*]
+[*Example 5*:
 Replacing an existing facet is even easier. The code does not define a
 member `id` because it is reusing the `numpunct<charT>` facet interface:
 ``` cpp
 // file: my_bool.C
 #include <iostream>
 #include <locale>
 #include <string>
 namespace My {
   using namespace std;
+ using cnumpunct = numpunct_byname<char>;
   class BoolNames : public cnumpunct {
   protected:
     string do_truename()  const { return "Oui Oui!"; }
     string do_falsename() const { return "Mais Non!"; }
     ~BoolNames() { }
   using namespace std;
   // make the user's preferred locale, except for...
   locale loc(locale(""), new My::BoolNames(""));
   cout.imbue(loc);
   cout << boolalpha << "Any arguments today? " << (argc > 1) << endl;
 }
 ```
+— *end example*]

Diff to HTML by rtfpessoa