[localization] - C++14 → C++17

Files changed (1) hide show

tmp/tmplpwcgig3/{from.md → to.md} +499 -825

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

@@ -13,27 +13,26 @@ standard facets, and facilities from the ISO C library, as summarized in
 Table  [[tab:localization.lib.summary]].
 **Table: Localization library summary** <a id="tab:localization.lib.summary">[tab:localization.lib.summary]</a>
 | Subclause             |                              | Header      |
-| --------------------- | ------------------------------- | ----------- |
 | [[locales]]           | Locales                      | `<locale>`  |
 | [[locale.categories]] | Standard `locale` Categories |             |
-| [[locale.stdcvt]]     | Standard code conversion facets | `<codecvt>` |
 | [[c.locales]]         | C library locales            | `<clocale>` |
 ## Header `<locale>` synopsis <a id="locale.syn">[[locale.syn]]</a>
 ``` cpp
 namespace std {
-  // [locale], locale:
   class locale;
   template <class Facet> const Facet& use_facet(const locale&);
   template <class Facet> bool         has_facet(const locale&) noexcept;
-  // [locale.convenience], convenience interfaces:
   template <class charT> bool isspace (charT c, const locale& loc);
   template <class charT> bool isprint (charT c, const locale& loc);
   template <class charT> bool iscntrl (charT c, const locale& loc);
   template <class charT> bool isupper (charT c, const locale& loc);
   template <class charT> bool islower (charT c, const locale& loc);
@@ -44,54 +43,57 @@ namespace std {
   template <class charT> bool isalnum (charT c, const locale& loc);
   template <class charT> bool isgraph (charT c, const locale& loc);
   template <class charT> bool isblank (charT c, const locale& loc);
   template <class charT> charT toupper(charT c, const locale& loc);
   template <class charT> charT tolower(charT c, const locale& loc);
-  template <class Codecvt, class Elem = wchar_t,
-    class Wide_alloc = std::allocator<Elem>,
-    class Byte_alloc = std::allocator<char> > class wstring_convert;
-  template <class Codecvt, class Elem = wchar_t,
-     class Tr = char_traits<Elem>>{} class wbuffer_convert;
-  // [category.ctype], ctype:
   class ctype_base;
   template <class charT> class ctype;
   template <>            class ctype<char>;     // specialization
   template <class charT> class ctype_byname;
   class codecvt_base;
   template <class internT, class externT, class stateT> class codecvt;
   template <class internT, class externT, class stateT> class codecvt_byname;
-  // [category.numeric], numeric:
-  template <class charT, class InputIterator = istreambuf_iterator<charT> >  class num_get;
-  template <class charT, class OutputIterator = ostreambuf_iterator<charT> > class num_put;
-  template <class charT> class numpunct;
-  template <class charT> class numpunct_byname;
-  // [category.collate], collation:
   template <class charT> class collate;
   template <class charT> class collate_byname;
-  // [category.time], date and time:
   class time_base;
   template <class charT, class InputIterator = istreambuf_iterator<charT>>
     class time_get;
   template <class charT, class InputIterator = istreambuf_iterator<charT>>
     class time_get_byname;
   template <class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class time_put;
   template <class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class time_put_byname;
-  // [category.monetary], money:
   class money_base;
-  template <class charT, class InputIterator = istreambuf_iterator<charT> >  class money_get;
-  template <class charT, class OutputIterator = ostreambuf_iterator<charT> > class money_put;
-  template <class charT, bool Intl = false> class moneypunct;
-  template <class charT, bool Intl = false> class moneypunct_byname;
-  // [category.messages], message retrieval:
   class messages_base;
   template <class charT> class messages;
   template <class charT> class messages_byname;
 }
 ```
@@ -108,11 +110,11 @@ namespace std {
   class locale {
   public:
     // types:
     class facet;
     class id;
- typedef int category;
     static const category   // values assigned here are for exposition only
       none     = 0,
       collate  = 0x010, ctype    = 0x020,
       monetary = 0x040, numeric  = 0x080,
       time     = 0x100, messages = 0x200,
@@ -154,10 +156,12 @@ it’s just a class interface; at the same time, it’s an index into a
 locale’s set of facets.
 Access to the facets of a `locale` is via two function templates,
 `use_facet<>` and `has_facet<>`.
 An iostream `operator<<` might be implemented as:[^2]
 ``` cpp
 template <class charT, class traits>
 basic_ostream<charT, traits>&
@@ -172,18 +176,22 @@ operator<< (basic_ostream<charT,traits>& s, Date d) {
   }
   return s;
 }
 ```
 In the call to `use_facet<Facet>(loc)`, the type argument chooses a
 facet, making available all members of the named type. If `Facet` is not
 present in a locale, it throws the standard exception `bad_cast`. A
 C++program can check if a locale implements a particular facet with the
 function template `has_facet<Facet>()`. User-defined facets may be
 installed in a locale, and used identically as may standard facets (
 [[facets.examples]]).
 All locale semantics are accessed via `use_facet<>` and `has_facet<>`,
 except that:
 - A member operator template
   `operator()(const basic_string<C, T, A>&, const basic_string<{}C, T, A>&)`
@@ -192,10 +200,12 @@ except that:
 - Convenient global interfaces are provided for traditional `ctype`
   functions such as `isdigit()` and `isspace()`, so that given a locale
   object `loc` a C++program can call `isspace(c, loc)`. (This eases
   upgrading existing extractors ([[istream.formatted]]).)
 Once a facet reference is obtained from a locale object by calling
 `use_facet<>`, that reference remains usable, and the results from
 member functions of it may be cached and re-used, as long as some locale
 object refers to that facet.
@@ -218,11 +228,11 @@ implementations are not required to avoid data races on it (
 #### `locale` types <a id="locale.types">[[locale.types]]</a>
 ##### Type `locale::category` <a id="locale.category">[[locale.category]]</a>
 ``` cpp
-typedef int category;
 ```
 *Valid* `category` values include the `locale` member bitmask elements
 `collate`, `ctype`, `monetary`, `numeric`, `time`, and `messages`, each
 of which represents a single locale category. In addition, `locale`
@@ -248,11 +258,11 @@ including at least those shown in Table
 [[tab:localization.category.facets]].
 **Table: Locale category facets** <a id="tab:localization.category.facets">[tab:localization.category.facets]</a>
 | Category | Includes facets                                       |
-| -------- | --------------------------------------------------- |
 | collate  | `collate<char>`, `collate<wchar_t>`                   |
 | ctype    | `ctype<char>`, `ctype<wchar_t>`                       |
 |          | `codecvt<char, char, mbstate_t>`                      |
 |          | `codecvt<char16_t, char, mbstate_t>`                  |
 |          | `codecvt<char32_t, char, mbstate_t>`                  |
@@ -269,22 +279,22 @@ including at least those shown in Table
 | messages | `messages<char>`, `messages<wchar_t>`                 |
 For any locale `loc` either constructed, or returned by
 `locale::classic()`, and any facet `Facet` shown in Table
-[[tab:localization.category.facets]], `has_facet<Facet>(loc)` is true.
 Each `locale` member function which takes a `locale::category` argument
 operates on the corresponding set of facets.
 An implementation is required to provide those specializations for facet
 templates identified as members of a category, and for those shown in
 Table  [[tab:localization.required.specializations]].
 **Table: Required specializations** <a id="tab:localization.required.specializations">[tab:localization.required.specializations]</a>
 | Category | Includes facets                                           |
-| -------- | ------------------------------------------------------- |
 | collate  | `collate_byname<char>`, `collate_byname<wchar_t>`         |
 | ctype    | `ctype_byname<char>`, `ctype_byname<wchar_t>`             |
 |          | `codecvt_byname<char, char, mbstate_t>`                   |
 |          | `codecvt_byname<char16_t, char, mbstate_t>`               |
 |          | `codecvt_byname<char32_t, char, mbstate_t>`               |
@@ -316,14 +326,14 @@ In declarations of facets, a template parameter with name
 `InputIterator` or `OutputIterator` indicates the set of all possible
 specializations on parameters that satisfy the requirements of an Input
 Iterator or an Output Iterator, respectively (
 [[iterator.requirements]]). A template parameter with name `C`
 represents the set of types containing `char`, `wchar_t`, and any other
-implementation-defined character types that satisfy the requirements for
-a character on which any of the iostream components can be instantiated.
-A template parameter with name `International` represents the set of all
-possible specializations on a bool parameter.
 ##### Class `locale::facet` <a id="locale.facet">[[locale.facet]]</a>
 ``` cpp
 namespace std {
@@ -335,25 +345,32 @@ namespace std {
     void operator=(const facet&) = delete;
   };
 }
 ```
 Template parameters in this Clause which are required to be facets are
 those named `Facet` in declarations. A program that passes a type that
 is *not* a facet, or a type that refers to a volatile-qualified facet,
 as an (explicit or deduced) template parameter to a locale function
 expecting a facet, is ill-formed. A const-qualified facet is a valid
 template argument to any locale function that expects a Facet template
 parameter.
 The `refs` argument to the constructor is used for lifetime management.
-- For `refs == 0`, the implementation performs
 `delete static_cast<locale::facet*>(f)` (where `f` is a pointer to the
- facet) when the last `locale` object containing the facet is
-  destroyed; for `refs == 1`, the implementation never destroys the
-  facet.
 Constructors of all facets defined in this Clause take such an argument
 and pass it along to their `facet` base class constructor. All
 one-argument constructors defined in this Clause are *explicit*,
 preventing their participation in automatic conversions.
@@ -381,21 +398,21 @@ namespace std {
     id(const id&) = delete;
   };
 }
 ```
-The class locale::id provides identification of a locale facet
 interface, used as an index for lookup and to encapsulate
 initialization.
-Because facets are used by iostreams, potentially while static
-constructors are running, their initialization cannot depend on
 programmed static initialization. One initialization strategy is for
 `locale` to initialize each facet’s `id` member the first time an
 instance of the facet is installed into a locale. This depends only on
 static storage being zero before constructors run (
-[[basic.start.init]]).
 #### `locale` constructors and destructor <a id="locale.cons">[[locale.cons]]</a>
 ``` cpp
 locale() noexcept;
@@ -404,12 +421,15 @@ locale() noexcept;
 Default constructor: a snapshot of the current global locale.
 *Effects:* Constructs a copy of the argument last passed to
 `locale::global(locale&)`, if it has been called; else, the resulting
 facets have virtual function semantics identical to those of
-`locale::classic()`. This constructor is commonly used as the default
-value for arguments of functions that take a `const locale&` argument.
 ``` cpp
 locale(const locale& other) noexcept;
 ```
@@ -478,11 +498,11 @@ arguments have names.
 const locale& operator=(const locale& other) noexcept;
 ```
 *Effects:* Creates a copy of `other`, replacing the current value.
-*Returns:* `*this`
 ``` cpp
 ~locale();
 ```
@@ -497,23 +517,20 @@ template <class Facet> locale combine(const locale& other) const;
 *Effects:* Constructs a locale incorporating all facets from `*this`
 except for that one facet of `other` that is identified by `Facet`.
 *Returns:* The newly created locale.
-*Throws:* `runtime_error` if `has_facet<Facet>(other)` is false.
 *Remarks:* The resulting locale has no name.
 ``` cpp
 basic_string<char> name() const;
 ```
 *Returns:* The name of `*this`, if it has one; otherwise, the string
-`"*"`. If `*this` has a name, then
-`locale(name().c`\textunderscore`str())` is equivalent to `*this`.
-Details of the contents of the resulting string are otherwise
-implementation-defined.
 #### `locale` operators <a id="locale.operators">[[locale.operators]]</a>
 ``` cpp
 bool operator==(const locale& other) const;
@@ -525,11 +542,11 @@ copy of the other, or each has a name and the names are identical;
 ``` cpp
 bool operator!=(const locale& other) const;
 ```
-*Returns:* The result of the expression: `!(*this == other)`.
 ``` cpp
 template <class charT, class traits, class Allocator>
   bool operator()(const basic_string<charT, traits, Allocator>& s1,
                   const basic_string<charT, traits, Allocator>& s2) const;
@@ -539,24 +556,28 @@ template <class charT, class traits, class Allocator>
 *Remarks:* This member operator template (and therefore `locale` itself)
 satisfies requirements for a comparator predicate template argument
 (Clause  [[algorithms]]) applied to strings.
-*Returns:* The result of the following expression:
 ``` cpp
-use_facet< collate<charT> >(*this).compare
-  (s1.data(), s1.data()+s1.size(), s2.data(), s2.data()+s2.size()) < 0;
 ```
 A vector of strings `v` can be collated according to collation rules in
 locale `loc` simply by ([[alg.sort]], [[vector]]):
 ``` cpp
 std::sort(v.begin(), v.end(), loc);
 ```
 #### `locale` static members <a id="locale.statics">[[locale.statics]]</a>
 ``` cpp
 static locale global(const locale& loc);
 ```
@@ -565,18 +586,19 @@ Sets the global locale to its argument.
 *Effects:* Causes future calls to the constructor `locale()` to return a
 copy of the argument. If the argument has a name, does
 ``` cpp
-std::setlocale(LC_ALL, loc.name().c_str());
 ```
 otherwise, the effect on the C locale, if any, is
 *implementation-defined*. No library function other than
 `locale::global()` shall affect the value returned by `locale()`.
-See  [[c.locales]] for data race considerations when `setlocale` is
-invoked.
 *Returns:* The previous value of `locale()`.
 ``` cpp
 static const locale& classic();
@@ -608,12 +630,12 @@ copy of `loc` exists.
 ``` cpp
 template <class Facet> bool has_facet(const locale& loc) noexcept;
 ```
-*Returns:* True if the facet requested is present in `loc`; otherwise
-false.
 ### Convenience interfaces <a id="locale.convenience">[[locale.convenience]]</a>
 #### Character classification <a id="classification">[[classification]]</a>
@@ -630,19 +652,18 @@ template <class charT> bool isxdigit(charT c, const locale& loc);
 template <class charT> bool isalnum (charT c, const locale& loc);
 template <class charT> bool isgraph (charT c, const locale& loc);
 template <class charT> bool isblank (charT c, const locale& loc);
 ```
-Each of these functions `is\textbf{F}` returns the result of the
-expression:
 ``` cpp
 use_facet<ctype<charT>>(loc).is(ctype_base::F, c)
 ```
-where ***F*** is the `ctype_base::mask` value corresponding to that
-function ([[category.ctype]]).[^3]
 #### Conversions <a id="conversions">[[conversions]]</a>
 ##### Character conversions <a id="conversions.character">[[conversions.character]]</a>
@@ -656,304 +677,10 @@ template <class charT> charT toupper(charT c, const locale& loc);
 template <class charT> charT tolower(charT c, const locale& loc);
 ```
 *Returns:* `use_facet<ctype<charT>>(loc).tolower(c)`.
-##### `string` conversions <a id="conversions.string">[[conversions.string]]</a>
-Class template `wstring_convert` performs conversions between a wide
-string and a byte string. It lets you specify a code conversion facet
-(like class template `codecvt`) to perform the conversions, without
-affecting any streams or locales. If you want to use the code conversion
-facet `codecvt_utf8` to output to `cout` a UTF-8 multibyte sequence
-corresponding to a wide string, but you don’t want to alter the locale
-for `cout`, you can write something like:
-``` cpp
-wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
-std::string mbstring = myconv.to_bytes(L"Hello\n");
-std::cout << mbstring;
-```
-``` cpp
-namespace std {
-template<class Codecvt, class Elem = wchar_t,
-    class Wide_alloc = std::allocator<Elem>,
-    class Byte_alloc = std::allocator<char> > class wstring_convert {
-  public:
-    typedef std::basic_string<char, char_traits<char>, Byte_alloc> byte_string;
-    typedef std::basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
-    typedef typename Codecvt::state_type state_type;
-    typedef typename wide_string::traits_type::int_type int_type;
-    explicit wstring_convert(Codecvt* pcvt = new Codecvt);
-    wstring_convert(Codecvt* pcvt, state_type state);
-    explicit wstring_convert(const byte_string& byte_err,
-                             const wide_string& wide_err = wide_string());
-    ~wstring_convert();
-    wstring_convert(const wstring_convert&) = delete;
-    wstring_convert& operator=(const wstring_convert&) = delete;
-    wide_string from_bytes(char byte);
-    wide_string from_bytes(const char* ptr);
-    wide_string from_bytes(const byte_string& str);
-    wide_string from_bytes(const char* first, const char* last);
-    byte_string to_bytes(Elem wchar);
-    byte_string to_bytes(const Elem* wptr);
-    byte_string to_bytes(const wide_string& wstr);
-    byte_string to_bytes(const Elem* first, const Elem* last);
-    size_t converted() const noexcept;
-    state_type state() const;
-  private:
-    byte_string byte_err_string;    // exposition only
-    wide_string wide_err_string;    // exposition only
-    Codecvt* cvtptr;                // exposition only
-    state_type cvtstate;            // exposition only
-    size_t cvtcount;                // exposition only
-  };
-}
-```
-The class template describes an object that controls conversions between
-wide string objects of class `std::basic_string<Elem, char_traits<Elem>,
-Wide_alloc>` and byte string objects of class `std::\\basic_string<char,
-char_traits<char>, Byte_alloc>`. The class template defines the types
-`wide_string` and `byte_string` as synonyms for these two types.
-Conversion between a sequence of `Elem` values (stored in a
-`wide_string` object) and multibyte sequences (stored in a `byte_string`
-object) is performed by an object of class `Codecvt`, which meets the
-requirements of the standard code-conversion facet `std::codecvt<Elem,
-char, std::mbstate_t>`.
-An object of this class template stores:
-- `byte_err_string` — a byte string to display on errors
-- `wide_err_string` — a wide string to display on errors
-- `cvtptr` — a pointer to the allocated conversion object (which is
-  freed when the `wstring_convert` object is destroyed)
-- `cvtstate` — a conversion state object
-- `cvtcount` — a conversion count
-``` cpp
-typedef std::basic_string<char, char_traits<char>, Byte_alloc> byte_string;
-```
-The type shall be a synonym for
-`std::basic_string<char, char_traits<char>, Byte_alloc>`
-``` cpp
-size_t converted() const noexcept;
-```
-*Returns:* `cvtcount`.
-``` cpp
-wide_string from_bytes(char byte);
-wide_string from_bytes(const char* ptr);
-wide_string from_bytes(const byte_string& str);
-wide_string from_bytes(const char* first, const char* last);
-```
-*Effects:* The first member function shall convert the single-element
-sequence `byte` to a wide string. The second member function shall
-convert the null-terminated sequence beginning at `ptr` to a wide
-string. The third member function shall convert the sequence stored in
-`str` to a wide string. The fourth member function shall convert the
-sequence defined by the range \[`first`, `last`) to a wide string.
-In all cases:
-- If the `cvtstate` object was not constructed with an explicit value,
-  it shall be set to its default value (the initial conversion state)
-  before the conversion begins. Otherwise it shall be left unchanged.
-- The number of input elements successfully converted shall be stored in
-  `cvtcount`.
-*Returns:* If no conversion error occurs, the member function shall
-return the converted wide string. Otherwise, if the object was
-constructed with a wide-error string, the member function shall return
-the wide-error string. Otherwise, the member function throws an object
-of class `std::range_error`.
-``` cpp
-typedef typename wide_string::traits_type::int_type int_type;
-```
-The type shall be a synonym for `wide_string::traits_type::int_type`.
-``` cpp
-state_type state() const;
-```
-returns `cvtstate`.
-``` cpp
-typedef typename Codecvt::state_type state_type;
-```
-The type shall be a synonym for `Codecvt::state_type`.
-``` cpp
-byte_string to_bytes(Elem wchar);
-byte_string to_bytes(const Elem* wptr);
-byte_string to_bytes(const wide_string& wstr);
-byte_string to_bytes(const Elem* first, const Elem* last);
-```
-*Effects:* The first member function shall convert the single-element
-sequence `wchar` to a byte string. The second member function shall
-convert the null-terminated sequence beginning at `wptr` to a byte
-string. The third member function shall convert the sequence stored in
-`wstr` to a byte string. The fourth member function shall convert the
-sequence defined by the range \[`first`, `last`) to a byte string.
-In all cases:
-- If the `cvtstate` object was not constructed with an explicit value,
-  it shall be set to its default value (the initial conversion state)
-  before the conversion begins. Otherwise it shall be left unchanged.
-- The number of input elements successfully converted shall be stored in
-  `cvtcount`.
-*Returns:* If no conversion error occurs, the member function shall
-return the converted byte string. Otherwise, if the object was
-constructed with a byte-error string, the member function shall return
-the byte-error string. Otherwise, the member function shall throw an
-object of class `std::range_error`.
-``` cpp
-typedef std::basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
-```
-The type shall be a synonym for
-`std::basic_string<Elem, char_traits<Elem>, Wide_alloc>`.
-``` cpp
-explicit wstring_convert(Codecvt* pcvt = new Codecvt);
-wstring_convert(Codecvt* pcvt, state_type state);
-explicit wstring_convert(const byte_string& byte_err,
-    const wide_string& wide_err = wide_string());
-```
-*Requires:* For the first and second constructors, `pcvt != nullptr`.
-*Effects:* The first constructor shall store `pcvt` in `cvtptr` and
-default values in `cvtstate`, `byte_err_string`, and `wide_err_string`.
-The second constructor shall store `pcvt` in `cvtptr`, `state` in
-`cvtstate`, and default values in `byte_err_string` and
-`wide_err_string`; moreover the stored state shall be retained between
-calls to `from_bytes` and `to_bytes`. The third constructor shall store
-`new Codecvt` in `cvtptr`, `state_type()` in `cvtstate`, `byte_err` in
-`byte_err_string`, and `wide_err` in `wide_err_string`.
-``` cpp
-~wstring_convert();
-```
-*Effects:* The destructor shall delete `cvtptr`.
-##### Buffer conversions <a id="conversions.buffer">[[conversions.buffer]]</a>
-Class template `wbuffer_convert` looks like a wide stream buffer, but
-performs all its I/O through an underlying byte stream buffer that you
-specify when you construct it. Like class template `wstring_convert`, it
-lets you specify a code conversion facet to perform the conversions,
-without affecting any streams or locales.
-``` cpp
-namespace std {
-template<class Codecvt,
-    class Elem = wchar_t,
-    class Tr = std::char_traits<Elem> >
-  class wbuffer_convert
-    : public std::basic_streambuf<Elem, Tr> {
-  public:
-    typedef typename Codecvt::state_type state_type;
-    explicit wbuffer_convert(std::streambuf* bytebuf = 0,
-                             Codecvt* pcvt = new Codecvt,
-                             state_type state = state_type());
-    ~wbuffer_convert();
-    wbuffer_convert(const wbuffer_convert&) = delete;
-    wbuffer_convert& operator=(const wbuffer_convert&) = delete;
-    std::streambuf* rdbuf() const;
-    std::streambuf* rdbuf(std::streambuf* bytebuf);
-    state_type state() const;
-  private:
-    std::streambuf* bufptr;         // exposition only
-    Codecvt* cvtptr;                // exposition only
-    state_type cvtstate;            // exposition only
-  };
-}
-```
-The class template describes a stream buffer that controls the
-transmission of elements of type `Elem`, whose character traits are
-described by the class `Tr`, to and from a byte stream buffer of type
-`std::streambuf`. Conversion between a sequence of `Elem` values and
-multibyte sequences is performed by an object of class `Codecvt`, which
-shall meet the requirements of the standard code-conversion facet
-`std::codecvt<Elem, char, std::mbstate_t>`.
-An object of this class template stores:
-- `bufptr` — a pointer to its underlying byte stream buffer
-- `cvtptr` — a pointer to the allocated conversion object (which is
-  freed when the `wbuffer_convert` object is destroyed)
-- `cvtstate` — a conversion state object
-``` cpp
-state_type state() const;
-```
-*Returns:* `cvtstate`.
-``` cpp
-std::streambuf* rdbuf() const;
-```
-*Returns:* `bufptr`.
-``` cpp
-std::streambuf* rdbuf(std::streambuf* bytebuf);
-```
-*Effects:* stores `bytebuf` in `bufptr`.
-*Returns:* The previous value of `bufptr`.
-``` cpp
-typedef typename Codecvt::state_type state_type;
-```
-The type shall be a synonym for `Codecvt::state_type`.
-``` cpp
-explicit wbuffer_convert(std::streambuf* bytebuf = 0,
-    Codecvt* pcvt = new Codecvt, state_type state = state_type());
-```
-*Requires:* `pcvt != nullptr`.
-*Effects:* The constructor constructs a stream buffer object,
-initializes `bufptr` to `bytebuf`, initializes `cvtptr` to `pcvt`, and
-initializes `cvtstate` to `state`.
-``` cpp
-~wbuffer_convert();
-```
-*Effects:* The destructor shall delete `cvtptr`.
 ## Standard `locale` categories <a id="locale.categories">[[locale.categories]]</a>
 Each of the standard categories includes a family of facets. Some of
 these implement formatting or parsing of a datum, for use by standard or
 users’ iostream operators `<<` and `>>`, as members `put()` and `get()`,
@@ -977,11 +704,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;
@@ -1005,49 +732,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;
     };
 }
@@ -1068,54 +788,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;
@@ -1124,30 +844,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`.
@@ -1187,16 +906,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
@@ -1241,11 +960,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();
     };
@@ -1254,14 +973,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;
@@ -1306,21 +1025,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
@@ -1330,22 +1049,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
@@ -1407,22 +1127,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;
@@ -1453,46 +1173,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;
     };
 }
 ```
@@ -1506,103 +1234,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
@@ -1625,105 +1355,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>
@@ -1743,11 +1475,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]] (
@@ -1768,12 +1500,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;
@@ -1945,12 +1677,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())
@@ -1968,11 +1700,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
@@ -1989,54 +1721,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`.
@@ -2044,127 +1782,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.
@@ -2189,10 +1902,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.
@@ -2250,15 +1964,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
@@ -2294,11 +2008,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           |
@@ -2324,12 +2038,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
@@ -2350,12 +2063,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;
@@ -2414,23 +2127,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;
 ```
@@ -2457,14 +2170,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
@@ -2484,12 +2197,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();
   };
@@ -2503,12 +2217,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;
@@ -2544,23 +2258,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,
@@ -2578,30 +2292,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();
     };
@@ -2615,12 +2332,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
@@ -2631,12 +2348,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,
@@ -2677,81 +2394,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
@@ -2762,36 +2479,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,
@@ -2878,24 +2596,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`.
@@ -2904,12 +2622,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();
@@ -2922,12 +2640,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,
@@ -2962,20 +2680,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>
@@ -2987,29 +2705,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();
@@ -3025,25 +2745,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,
@@ -3072,11 +2791,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,
@@ -3097,13 +2816,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.
@@ -3119,27 +2842,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;
@@ -3160,17 +2886,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;
@@ -3196,11 +2921,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,
@@ -3235,16 +2960,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>
@@ -3258,12 +2985,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;
@@ -3295,11 +3022,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,
@@ -3362,56 +3089,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;
 ```
@@ -3419,21 +3146,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();
@@ -3450,18 +3177,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,
@@ -3490,12 +3217,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
@@ -3505,12 +3231,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
@@ -3520,12 +3245,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.
@@ -3541,21 +3265,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();
@@ -3568,11 +3292,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>
@@ -3590,10 +3317,14 @@ int main(int argc, char** argv) {
   return MyObject(argc, argv).doit();
 }
 ```
 Greater flexibility is possible:
 ``` cpp
 #include <iostream>
 #include <locale>
@@ -3607,13 +3338,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>
@@ -3661,15 +3396,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>
@@ -3691,33 +3430,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() { }
@@ -3730,113 +3472,45 @@ 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;
 }
 ```
-## Standard code conversion facets <a id="locale.stdcvt">[[locale.stdcvt]]</a>
-The header `<codecvt>` provides code conversion facets for various
-character encodings.
-``` cpp
-namespace std {
-  enum codecvt_mode {
-    consume_header = 4,
-    generate_header = 2,
-    little_endian = 1
-  };
-  template<class Elem, unsigned long Maxcode = 0x10ffff,
-    codecvt_mode Mode = (codecvt_mode)0>
-  class codecvt_utf8
-    : public codecvt<Elem, char, mbstate_t> {
-  public:
-    explicit codecvt_utf8(size_t refs = 0);
-    ~codecvt_utf8();
-  };
-  template<class Elem, unsigned long Maxcode = 0x10ffff,
-    codecvt_mode Mode = (codecvt_mode)0>
-  class codecvt_utf16
-    : public codecvt<Elem, char, mbstate_t> {
-  public:
-    explicit codecvt_utf16(size_t refs = 0);
-    ~codecvt_utf16();
-  };
-  template<class Elem, unsigned long Maxcode = 0x10ffff,
-    codecvt_mode Mode = (codecvt_mode)0>
-  class codecvt_utf8_utf16
-    : public codecvt<Elem, char, mbstate_t> {
-  public:
-    explicit codecvt_utf8_utf16(size_t refs = 0);
-    ~codecvt_utf8_utf16();
-  };
-}
-```
-For each of the three code conversion facets `codecvt_utf8`,
-`codecvt_utf16`, and `codecvt_utf8_utf16`:
-- `Elem` is the wide-character type, such as `wchar_t`, `char16_t`, or
-  `char32_t`.
-- `Maxcode` is the largest wide-character code that the facet will read
-  or write without reporting a conversion error.
-- If `(Mode & consume_header)`, the facet shall consume an initial
-  header sequence, if present, when reading a multibyte sequence to
-  determine the endianness of the subsequent multibyte sequence to be
-  read.
-- If `(Mode & generate_header)`, the facet shall generate an initial
-  header sequence when writing a multibyte sequence to advertise the
-  endianness of the subsequent multibyte sequence to be written.
-- If `(Mode & little_endian)`, the facet shall generate a multibyte
-  sequence in little-endian order, as opposed to the default big-endian
-  order.
-For the facet `codecvt_utf8`:
-- The facet shall convert between UTF-8 multibyte sequences and UCS2 or
-  UCS4 (depending on the size of `Elem`) within the program.
-- Endianness shall not affect how multibyte sequences are read or
-  written.
-- The multibyte sequences may be written as either a text or a binary
-  file.
-For the facet `codecvt_utf16`:
-- The facet shall convert between UTF-16 multibyte sequences and UCS2 or
-  UCS4 (depending on the size of `Elem`) within the program.
-- Multibyte sequences shall be read or written according to the `Mode`
-  flag, as set out above.
-- The multibyte sequences may be written only as a binary file.
-  Attempting to write to a text file produces undefined behavior.
-For the facet `codecvt_utf8_utf16`:
-- The facet shall convert between UTF-8 multibyte sequences and UTF-16
-  (one or two 16-bit codes) within the program.
-- Endianness shall not affect how multibyte sequences are read or
-  written.
-- The multibyte sequences may be written as either a text or a binary
-  file.
-ISO/IEC 10646-1:1993.
 ## C library locales <a id="c.locales">[[c.locales]]</a>
-Table  [[tab:localization.hdr.clocale]] describes header `<clocale>`.
-The contents are the same as the Standard C library header `<locale.h>`.
 Calls to the function `setlocale` may introduce a data race (
 [[res.on.data.races]]) with other calls to `setlocale` or with calls to
 the functions listed in Table  [[tab:setlocale.data.races]].
 **Table: Potential `setlocale` data races** <a id="tab:setlocale.data.races">[tab:setlocale.data.races]</a>
 |           |            |             |              |            |
 | --------- | ---------- | ----------- | ------------ | ---------- |
 | `fprintf` | `isprint`  | `iswdigit`  | `localeconv` | `tolower`  |
@@ -3848,31 +3522,29 @@ the functions listed in Table  [[tab:setlocale.data.races]].
 | `isdigit` | `iswblank` | `iswupper`  | `strerror`   | `wcstombs` |
 | `isgraph` | `iswcntrl` | `iswxdigit` | `strtod`     | `wcsxfrm`  |
 | `islower` | `iswctype` | `isxdigit`  | `strxfrm`    | `wctomb`   |
-ISO C Clause 7.4.
 <!-- Link reference definitions -->
 [alg.lex.comparison]: algorithms.md#alg.lex.comparison
 [alg.sort]: algorithms.md#alg.sort
 [algorithms]: algorithms.md#algorithms
-[basic.start.init]: basic.md#basic.start.init
 [bitmask.types]: library.md#bitmask.types
 [c.files]: input.md#c.files
 [c.locales]: #c.locales
 [category.collate]: #category.collate
 [category.ctype]: #category.ctype
 [category.messages]: #category.messages
 [category.monetary]: #category.monetary
 [category.numeric]: #category.numeric
 [category.time]: #category.time
 [classification]: #classification
 [conversions]: #conversions
-[conversions.buffer]: #conversions.buffer
 [conversions.character]: #conversions.character
-[conversions.string]: #conversions.string
 [facet.ctype.char.dtor]: #facet.ctype.char.dtor
 [facet.ctype.char.members]: #facet.ctype.char.members
 [facet.ctype.char.statics]: #facet.ctype.char.statics
 [facet.ctype.char.virtuals]: #facet.ctype.char.virtuals
 [facet.ctype.special]: #facet.ctype.special
@@ -3929,11 +3601,10 @@ ISO C Clause 7.4.
 [locale.num.get]: #locale.num.get
 [locale.numpunct]: #locale.numpunct
 [locale.numpunct.byname]: #locale.numpunct.byname
 [locale.operators]: #locale.operators
 [locale.statics]: #locale.statics
-[locale.stdcvt]: #locale.stdcvt
 [locale.syn]: #locale.syn
 [locale.time.get]: #locale.time.get
 [locale.time.get.byname]: #locale.time.get.byname
 [locale.time.get.members]: #locale.time.get.members
 [locale.time.get.virtuals]: #locale.time.get.virtuals
@@ -3950,11 +3621,10 @@ ISO C Clause 7.4.
 [sequence.reqmts]: containers.md#sequence.reqmts
 [tab:lib.locale.time.get.virtuals.dogetdate]: #tab:lib.locale.time.get.virtuals.dogetdate
 [tab:localization.category.facets]: #tab:localization.category.facets
 [tab:localization.convert.result.values.out.in]: #tab:localization.convert.result.values.out.in
 [tab:localization.convert.result.values.unshift]: #tab:localization.convert.result.values.unshift
-[tab:localization.hdr.clocale]: #tab:localization.hdr.clocale
 [tab:localization.lib.summary]: #tab:localization.lib.summary
 [tab:localization.required.specializations]: #tab:localization.required.specializations
 [tab:setlocale.data.races]: #tab:setlocale.data.races
 [vector]: containers.md#vector
@@ -3962,85 +3632,89 @@ ISO C Clause 7.4.
     that is defined in `<ctime>`.
 [^2]: Note that in the call to `put` the stream is implicitly converted
     to an `ostreambuf_iterator<charT, traits>`.
-[^3]: When used in a loop, it is faster to cache the `ctype<>` facet and
     use it directly, or use the vector form of `ctype<>::is`.
-[^4]: The char argument of `do_widen` is intended to accept values
     derived from character literals for conversion to the locale’s
     encoding.
-[^5]: In other words, the transformed character is not a member of any
     character classification that `c` is not also a member of.
-[^6]: Only the `char` (not `unsigned char` and `signed char`) form is
     provided. The specialization is specified in the standard, and not
     left as an implementation detail, because it affects the derivation
     interface for `ctype<char>`.
-[^7]: Informally, this means that `basic_filebuf` assumes that the
     mappings from internal to external characters is 1 to N: a `codecvt`
     facet that is used by `basic_filebuf` must be able to translate
     characters one internal character at a time.
-[^8]: Typically these will be characters to return the state to
-    `stateT()`
-[^9]: If `encoding()` yields -1, then more than `max_length()` `externT`
-    elements may be consumed when producing a single `internT`
     character, and additional `externT` elements may appear at the end
     of a sequence after those that yield the final `internT` character.
-[^10]: Parsing `"-1"` correctly into, e.g., an `unsigned short` requires
     that the corresponding member `get()` at least extract the sign
     before delegating.
-[^11]: The conversion specification `#o` generates a leading `0` which
     is *not* a padding character.
-[^12]: Thus, the string `"\003"` specifies groups of 3 digits each, and
     `"3"` probably indicates groups of 51 (!) digits each, because 51 is
     the ASCII value of `"3"`.
-[^13]: This function is useful when one string is being compared to many
     other strings.
-[^14]: In other words, user confirmation is required for reliable
     parsing of user-entered dates and times, but machine-generated
     formats can be parsed reliably. This allows parsers to be aggressive
     about interpreting user variations on standard formats.
-[^15]: This function is intended as a convenience only, for common
     formats, and may return `no_order` in valid locales.
-[^16]: Although the C programming language defines no modifiers, most
     vendors do.
-[^17]: Interpretation of the `modifier` argument is
     implementation-defined, but should follow POSIX conventions.
-[^18]: Implementations are encouraged to refer to other standards such
     as POSIX for these definitions.
-[^19]: The semantics here are different from `ct.narrow`.
-[^20]: An array of `char`, rather than an array of `part`, is specified
     for `pattern::field` purely for efficiency.
-[^21]: In common U.S. locales this is `’.’`.
-[^22]: In common U.S. locales this is `’,’`.
-[^23]: To specify grouping by 3s, the value is `"\003"` *not* `"3"`.
-[^24]: For international specializations (second template parameter
     `true`) this is typically four characters long, usually three
     letters and a space.
-[^25]: This is usually the empty string.
-[^26]: In common U.S. locales, this is 2.
-[^27]: Note that the international symbol returned by `do_curr_sym()`
     usually contains a space, itself; for example, `"USD "`.

 Table  [[tab:localization.lib.summary]].
 **Table: Localization library summary** <a id="tab:localization.lib.summary">[tab:localization.lib.summary]</a>
 | Subclause             |                              | Header      |
+| --------------------- | ---------------------------- | ----------- |
 | [[locales]]           | Locales                      | `<locale>`  |
 | [[locale.categories]] | Standard `locale` Categories |             |
 | [[c.locales]]         | C library locales            | `<clocale>` |
 ## Header `<locale>` synopsis <a id="locale.syn">[[locale.syn]]</a>
 ``` cpp
 namespace std {
+  // [locale], locale
   class locale;
   template <class Facet> const Facet& use_facet(const locale&);
   template <class Facet> bool         has_facet(const locale&) noexcept;
+  // [locale.convenience], convenience interfaces
   template <class charT> bool isspace (charT c, const locale& loc);
   template <class charT> bool isprint (charT c, const locale& loc);
   template <class charT> bool iscntrl (charT c, const locale& loc);
   template <class charT> bool isupper (charT c, const locale& loc);
   template <class charT> bool islower (charT c, const locale& loc);
   template <class charT> bool isalnum (charT c, const locale& loc);
   template <class charT> bool isgraph (charT c, const locale& loc);
   template <class charT> bool isblank (charT c, const locale& loc);
   template <class charT> charT toupper(charT c, const locale& loc);
   template <class charT> charT tolower(charT c, const locale& loc);
+  // [category.ctype], ctype
   class ctype_base;
   template <class charT> class ctype;
   template <>            class ctype<char>;     // specialization
   template <class charT> class ctype_byname;
   class codecvt_base;
   template <class internT, class externT, class stateT> class codecvt;
   template <class internT, class externT, class stateT> class codecvt_byname;
+  // [category.numeric], numeric
+  template <class charT, class InputIterator = istreambuf_iterator<charT>>
+ class num_get;
+  template <class charT, class OutputIterator = ostreambuf_iterator<charT>>
+ class num_put;
+  template <class charT>
+    class numpunct;
+  template <class charT>
+    class numpunct_byname;
+  // [category.collate], collation
   template <class charT> class collate;
   template <class charT> class collate_byname;
+  // [category.time], date and time
   class time_base;
   template <class charT, class InputIterator = istreambuf_iterator<charT>>
     class time_get;
   template <class charT, class InputIterator = istreambuf_iterator<charT>>
     class time_get_byname;
   template <class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class time_put;
   template <class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class time_put_byname;
+  // [category.monetary], money
   class money_base;
+  template <class charT, class InputIterator = istreambuf_iterator<charT>>
+ class money_get;
+  template <class charT, class OutputIterator = ostreambuf_iterator<charT>>
+ class money_put;
+  template <class charT, bool Intl = false>
+    class moneypunct;
+  template <class charT, bool Intl = false>
+    class moneypunct_byname;
+  // [category.messages], message retrieval
   class messages_base;
   template <class charT> class messages;
   template <class charT> class messages_byname;
 }
 ```
   class locale {
   public:
     // types:
     class facet;
     class id;
+ using category = int;
     static const category   // values assigned here are for exposition only
       none     = 0,
       collate  = 0x010, ctype    = 0x020,
       monetary = 0x040, numeric  = 0x080,
       time     = 0x100, messages = 0x200,
 locale’s set of facets.
 Access to the facets of a `locale` is via two function templates,
 `use_facet<>` and `has_facet<>`.
+[*Example 1*:
 An iostream `operator<<` might be implemented as:[^2]
 ``` cpp
 template <class charT, class traits>
 basic_ostream<charT, traits>&
   }
   return s;
 }
 ```
+— *end example*]
 In the call to `use_facet<Facet>(loc)`, the type argument chooses a
 facet, making available all members of the named type. If `Facet` is not
 present in a locale, it throws the standard exception `bad_cast`. A
 C++program can check if a locale implements a particular facet with the
 function template `has_facet<Facet>()`. User-defined facets may be
 installed in a locale, and used identically as may standard facets (
 [[facets.examples]]).
+[*Note 1*:
 All locale semantics are accessed via `use_facet<>` and `has_facet<>`,
 except that:
 - A member operator template
   `operator()(const basic_string<C, T, A>&, const basic_string<{}C, T, A>&)`
 - Convenient global interfaces are provided for traditional `ctype`
   functions such as `isdigit()` and `isspace()`, so that given a locale
   object `loc` a C++program can call `isspace(c, loc)`. (This eases
   upgrading existing extractors ([[istream.formatted]]).)
+— *end note*]
 Once a facet reference is obtained from a locale object by calling
 `use_facet<>`, that reference remains usable, and the results from
 member functions of it may be cached and re-used, as long as some locale
 object refers to that facet.
 #### `locale` types <a id="locale.types">[[locale.types]]</a>
 ##### Type `locale::category` <a id="locale.category">[[locale.category]]</a>
 ``` cpp
+using category = int;
 ```
 *Valid* `category` values include the `locale` member bitmask elements
 `collate`, `ctype`, `monetary`, `numeric`, `time`, and `messages`, each
 of which represents a single locale category. In addition, `locale`
 [[tab:localization.category.facets]].
 **Table: Locale category facets** <a id="tab:localization.category.facets">[tab:localization.category.facets]</a>
 | Category | Includes facets                                       |
+| -------- | ----------------------------------------------------- |
 | collate  | `collate<char>`, `collate<wchar_t>`                   |
 | ctype    | `ctype<char>`, `ctype<wchar_t>`                       |
 |          | `codecvt<char, char, mbstate_t>`                      |
 |          | `codecvt<char16_t, char, mbstate_t>`                  |
 |          | `codecvt<char32_t, char, mbstate_t>`                  |
 | messages | `messages<char>`, `messages<wchar_t>`                 |
 For any locale `loc` either constructed, or returned by
 `locale::classic()`, and any facet `Facet` shown in Table
+[[tab:localization.category.facets]], `has_facet<Facet>(loc)` is `true`.
 Each `locale` member function which takes a `locale::category` argument
 operates on the corresponding set of facets.
 An implementation is required to provide those specializations for facet
 templates identified as members of a category, and for those shown in
 Table  [[tab:localization.required.specializations]].
 **Table: Required specializations** <a id="tab:localization.required.specializations">[tab:localization.required.specializations]</a>
 | Category | Includes facets                                           |
+| -------- | --------------------------------------------------------- |
 | collate  | `collate_byname<char>`, `collate_byname<wchar_t>`         |
 | ctype    | `ctype_byname<char>`, `ctype_byname<wchar_t>`             |
 |          | `codecvt_byname<char, char, mbstate_t>`                   |
 |          | `codecvt_byname<char16_t, char, mbstate_t>`               |
 |          | `codecvt_byname<char32_t, char, mbstate_t>`               |
 `InputIterator` or `OutputIterator` indicates the set of all possible
 specializations on parameters that satisfy the requirements of an Input
 Iterator or an Output Iterator, respectively (
 [[iterator.requirements]]). A template parameter with name `C`
 represents the set of types containing `char`, `wchar_t`, and any other
+*implementation-defined* character types that satisfy the requirements
+for a character on which any of the iostream components can be
+instantiated. A template parameter with name `International` represents
+the set of all possible specializations on a bool parameter.
 ##### Class `locale::facet` <a id="locale.facet">[[locale.facet]]</a>
 ``` cpp
 namespace std {
     void operator=(const facet&) = delete;
   };
 }
 ```
+Class `facet` is the base class for locale feature sets. A class is a
+*facet* if it is publicly derived from another facet, or if it is a
+class derived from `locale::facet` and contains a publicly accessible
+declaration as follows: [^3]
+``` cpp
+static ::std::locale::id id;
+```
 Template parameters in this Clause which are required to be facets are
 those named `Facet` in declarations. A program that passes a type that
 is *not* a facet, or a type that refers to a volatile-qualified facet,
 as an (explicit or deduced) template parameter to a locale function
 expecting a facet, is ill-formed. A const-qualified facet is a valid
 template argument to any locale function that expects a Facet template
 parameter.
 The `refs` argument to the constructor is used for lifetime management.
+For `refs == 0`, the implementation performs
 `delete static_cast<locale::facet*>(f)` (where `f` is a pointer to the
+facet) when the last `locale` object containing the facet is destroyed;
+for `refs == 1`, the implementation never destroys the facet.
 Constructors of all facets defined in this Clause take such an argument
 and pass it along to their `facet` base class constructor. All
 one-argument constructors defined in this Clause are *explicit*,
 preventing their participation in automatic conversions.
     id(const id&) = delete;
   };
 }
 ```
+The class `locale::id` provides identification of a locale facet
 interface, used as an index for lookup and to encapsulate
 initialization.
+[*Note 1*: Because facets are used by iostreams, potentially while
+static constructors are running, their initialization cannot depend on
 programmed static initialization. One initialization strategy is for
 `locale` to initialize each facet’s `id` member the first time an
 instance of the facet is installed into a locale. This depends only on
 static storage being zero before constructors run (
+[[basic.start.static]]). — *end note*]
 #### `locale` constructors and destructor <a id="locale.cons">[[locale.cons]]</a>
 ``` cpp
 locale() noexcept;
 Default constructor: a snapshot of the current global locale.
 *Effects:* Constructs a copy of the argument last passed to
 `locale::global(locale&)`, if it has been called; else, the resulting
 facets have virtual function semantics identical to those of
+`locale::classic()`.
+[*Note 1*: This constructor is commonly used as the default value for
+arguments of functions that take a `const locale&`
+argument. — *end note*]
 ``` cpp
 locale(const locale& other) noexcept;
 ```
 const locale& operator=(const locale& other) noexcept;
 ```
 *Effects:* Creates a copy of `other`, replacing the current value.
+*Returns:* `*this`.
 ``` cpp
 ~locale();
 ```
 *Effects:* Constructs a locale incorporating all facets from `*this`
 except for that one facet of `other` that is identified by `Facet`.
 *Returns:* The newly created locale.
+*Throws:* `runtime_error` if `has_facet<Facet>(other)` is `false`.
 *Remarks:* The resulting locale has no name.
 ``` cpp
 basic_string<char> name() const;
 ```
 *Returns:* The name of `*this`, if it has one; otherwise, the string
+`"*"`.
 #### `locale` operators <a id="locale.operators">[[locale.operators]]</a>
 ``` cpp
 bool operator==(const locale& other) const;
 ``` cpp
 bool operator!=(const locale& other) const;
 ```
+*Returns:* `!(*this == other)`.
 ``` cpp
 template <class charT, class traits, class Allocator>
   bool operator()(const basic_string<charT, traits, Allocator>& s1,
                   const basic_string<charT, traits, Allocator>& s2) const;
 *Remarks:* This member operator template (and therefore `locale` itself)
 satisfies requirements for a comparator predicate template argument
 (Clause  [[algorithms]]) applied to strings.
+*Returns:*
 ``` cpp
+use_facet<collate<charT>>(*this).compare(s1.data(), s1.data() + s1.size(),
+ s2.data(), s2.data() + s2.size()) < 0
 ```
+[*Example 1*:
 A vector of strings `v` can be collated according to collation rules in
 locale `loc` simply by ([[alg.sort]], [[vector]]):
 ``` cpp
 std::sort(v.begin(), v.end(), loc);
 ```
+— *end example*]
 #### `locale` static members <a id="locale.statics">[[locale.statics]]</a>
 ``` cpp
 static locale global(const locale& loc);
 ```
 *Effects:* Causes future calls to the constructor `locale()` to return a
 copy of the argument. If the argument has a name, does
 ``` cpp
+setlocale(LC_ALL, loc.name().c_str());
 ```
 otherwise, the effect on the C locale, if any, is
 *implementation-defined*. No library function other than
 `locale::global()` shall affect the value returned by `locale()`.
+[*Note 1*: See  [[c.locales]] for data race considerations when
+`setlocale` is invoked. — *end note*]
 *Returns:* The previous value of `locale()`.
 ``` cpp
 static const locale& classic();
 ``` cpp
 template <class Facet> bool has_facet(const locale& loc) noexcept;
 ```
+*Returns:* `true` if the facet requested is present in `loc`; otherwise
+`false`.
 ### Convenience interfaces <a id="locale.convenience">[[locale.convenience]]</a>
 #### Character classification <a id="classification">[[classification]]</a>
 template <class charT> bool isalnum (charT c, const locale& loc);
 template <class charT> bool isgraph (charT c, const locale& loc);
 template <class charT> bool isblank (charT c, const locale& loc);
 ```
+Each of these functions `isF` returns the result of the expression:
 ``` cpp
 use_facet<ctype<charT>>(loc).is(ctype_base::F, c)
 ```
+where `F` is the `ctype_base::mask` value corresponding to that
+function ([[category.ctype]]).[^4]
 #### Conversions <a id="conversions">[[conversions]]</a>
 ##### Character conversions <a id="conversions.character">[[conversions.character]]</a>
 template <class charT> charT tolower(charT c, const locale& loc);
 ```
 *Returns:* `use_facet<ctype<charT>>(loc).tolower(c)`.
 ## Standard `locale` categories <a id="locale.categories">[[locale.categories]]</a>
 Each of the standard categories includes a family of facets. Some of
 these implement formatting or parsing of a datum, for use by standard or
 users’ iostream operators `<<` and `>>`, as members `put()` and `get()`,
 ``` 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*]
 ## C library locales <a id="c.locales">[[c.locales]]</a>
+### Header `<clocale>` synopsis <a id="clocale.syn">[[clocale.syn]]</a>
+``` cpp
+namespace std {
+  struct lconv;
+  char* setlocale(int category, const char* locale);
+  lconv* localeconv();
+}
+#define NULL see [support.types.nullptr]
+#define LC_ALL see below
+#define LC_COLLATE see below
+#define LC_CTYPE see below
+#define LC_MONETARY see below
+#define LC_NUMERIC see below
+#define LC_TIME see below
+```
+The contents and meaning of the header `<clocale>` are the same as the C
+standard library header `<locale.h>`.
 Calls to the function `setlocale` may introduce a data race (
 [[res.on.data.races]]) with other calls to `setlocale` or with calls to
 the functions listed in Table  [[tab:setlocale.data.races]].
+ISO C 7.11.
 **Table: Potential `setlocale` data races** <a id="tab:setlocale.data.races">[tab:setlocale.data.races]</a>
 |           |            |             |              |            |
 | --------- | ---------- | ----------- | ------------ | ---------- |
 | `fprintf` | `isprint`  | `iswdigit`  | `localeconv` | `tolower`  |
 | `isdigit` | `iswblank` | `iswupper`  | `strerror`   | `wcstombs` |
 | `isgraph` | `iswcntrl` | `iswxdigit` | `strtod`     | `wcsxfrm`  |
 | `islower` | `iswctype` | `isxdigit`  | `strxfrm`    | `wctomb`   |
 <!-- Link reference definitions -->
 [alg.lex.comparison]: algorithms.md#alg.lex.comparison
 [alg.sort]: algorithms.md#alg.sort
 [algorithms]: algorithms.md#algorithms
+[basic.start.static]: basic.md#basic.start.static
 [bitmask.types]: library.md#bitmask.types
 [c.files]: input.md#c.files
 [c.locales]: #c.locales
 [category.collate]: #category.collate
 [category.ctype]: #category.ctype
 [category.messages]: #category.messages
 [category.monetary]: #category.monetary
 [category.numeric]: #category.numeric
 [category.time]: #category.time
 [classification]: #classification
+[clocale.syn]: #clocale.syn
 [conversions]: #conversions
 [conversions.character]: #conversions.character
 [facet.ctype.char.dtor]: #facet.ctype.char.dtor
 [facet.ctype.char.members]: #facet.ctype.char.members
 [facet.ctype.char.statics]: #facet.ctype.char.statics
 [facet.ctype.char.virtuals]: #facet.ctype.char.virtuals
 [facet.ctype.special]: #facet.ctype.special
 [locale.num.get]: #locale.num.get
 [locale.numpunct]: #locale.numpunct
 [locale.numpunct.byname]: #locale.numpunct.byname
 [locale.operators]: #locale.operators
 [locale.statics]: #locale.statics
 [locale.syn]: #locale.syn
 [locale.time.get]: #locale.time.get
 [locale.time.get.byname]: #locale.time.get.byname
 [locale.time.get.members]: #locale.time.get.members
 [locale.time.get.virtuals]: #locale.time.get.virtuals
 [sequence.reqmts]: containers.md#sequence.reqmts
 [tab:lib.locale.time.get.virtuals.dogetdate]: #tab:lib.locale.time.get.virtuals.dogetdate
 [tab:localization.category.facets]: #tab:localization.category.facets
 [tab:localization.convert.result.values.out.in]: #tab:localization.convert.result.values.out.in
 [tab:localization.convert.result.values.unshift]: #tab:localization.convert.result.values.unshift
 [tab:localization.lib.summary]: #tab:localization.lib.summary
 [tab:localization.required.specializations]: #tab:localization.required.specializations
 [tab:setlocale.data.races]: #tab:setlocale.data.races
 [vector]: containers.md#vector
     that is defined in `<ctime>`.
 [^2]: Note that in the call to `put` the stream is implicitly converted
     to an `ostreambuf_iterator<charT, traits>`.
+[^3]: This is a complete list of requirements; there are no other
+    requirements. Thus, a facet class need not have a public copy
+    constructor, assignment, default constructor, destructor, etc.
+[^4]: When used in a loop, it is faster to cache the `ctype<>` facet and
     use it directly, or use the vector form of `ctype<>::is`.
+[^5]: The char argument of `do_widen` is intended to accept values
     derived from character literals for conversion to the locale’s
     encoding.
+[^6]: In other words, the transformed character is not a member of any
     character classification that `c` is not also a member of.
+[^7]: Only the `char` (not `unsigned char` and `signed char`) form is
     provided. The specialization is specified in the standard, and not
     left as an implementation detail, because it affects the derivation
     interface for `ctype<char>`.
+[^8]: Informally, this means that `basic_filebuf` assumes that the
     mappings from internal to external characters is 1 to N: a `codecvt`
     facet that is used by `basic_filebuf` must be able to translate
     characters one internal character at a time.
+[^9]: Typically these will be characters to return the state to
+    `stateT()`.
+[^10]: If `encoding()` yields `-1`, then more than `max_length()`
+ `externT` elements may be consumed when producing a single `internT`
     character, and additional `externT` elements may appear at the end
     of a sequence after those that yield the final `internT` character.
+[^11]: Parsing `"-1"` correctly into, e.g., an `unsigned short` requires
     that the corresponding member `get()` at least extract the sign
     before delegating.
+[^12]: The conversion specification `#o` generates a leading `0` which
     is *not* a padding character.
+[^13]: Thus, the string `"\003"` specifies groups of 3 digits each, and
     `"3"` probably indicates groups of 51 (!) digits each, because 51 is
     the ASCII value of `"3"`.
+[^14]: This function is useful when one string is being compared to many
     other strings.
+[^15]: In other words, user confirmation is required for reliable
     parsing of user-entered dates and times, but machine-generated
     formats can be parsed reliably. This allows parsers to be aggressive
     about interpreting user variations on standard formats.
+[^16]: This function is intended as a convenience only, for common
     formats, and may return `no_order` in valid locales.
+[^17]: Although the C programming language defines no modifiers, most
     vendors do.
+[^18]: Interpretation of the `modifier` argument is
     implementation-defined, but should follow POSIX conventions.
+[^19]: Implementations are encouraged to refer to other standards such
     as POSIX for these definitions.
+[^20]: The semantics here are different from `ct.narrow`.
+[^21]: An array of `char`, rather than an array of `part`, is specified
     for `pattern::field` purely for efficiency.
+[^22]: In common U.S. locales this is `’.’`.
+[^23]: In common U.S. locales this is `’,’`.
+[^24]: To specify grouping by 3s, the value is `"\003"` *not* `"3"`.
+[^25]: For international specializations (second template parameter
     `true`) this is typically four characters long, usually three
     letters and a space.
+[^26]: This is usually the empty string.
+[^27]: In common U.S. locales, this is 2.
+[^28]: Note that the international symbol returned by `do_curr_sym()`
     usually contains a space, itself; for example, `"USD "`.

Diff to HTML by rtfpessoa