[re] - C++17 → C++20

Files changed (1) hide show

tmp/tmpq9bklrof/{from.md → to.md} +308 -800

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

@@ -4,28 +4,28 @@
 This Clause describes components that C++ programs may use to perform
 operations involving regular expression matching and searching.
 The following subclauses describe a basic regular expression class
-template and its traits that can handle char-like ([[strings.general]])
 template arguments, two specializations of this class template that
 handle sequences of `char` and `wchar_t`, a class template that holds
 the result of a regular expression match, a series of algorithms that
 allow a character sequence to be operated upon by a regular expression,
 and two iterator types for enumerating regular expression matches, as
-described in Table  [[tab:re.lib.summary]].
-**Table: Regular expressions library summary** <a id="tab:re.lib.summary">[tab:re.lib.summary]</a>
 | Subclause       |                             | Header    |
 | --------------- | --------------------------- | --------- |
 | [[re.def]]      | Definitions                 |           |
 | [[re.req]]      | Requirements                |           |
-| [[re.const]]    | Constants                   | |
 | [[re.badexp]]   | Exception type              |           |
 | [[re.traits]]   | Traits                      |           |
-| [[re.regex]]    | Regular expression template | `<regex>` |
 | [[re.submatch]] | Submatches                  |           |
 | [[re.results]]  | Match results               |           |
 | [[re.alg]]      | Algorithms                  |           |
 | [[re.iter]]     | Iterators                   |           |
 | [[re.grammar]]  | Grammar                     |           |
@@ -74,46 +74,47 @@ a subset of a regular expression that has been marked by parenthesis.
 ## Requirements <a id="re.req">[[re.req]]</a>
 This subclause defines requirements on classes representing regular
 expression traits.
-[*Note 1*: The class template `regex_traits`, defined in Clause
-[[re.traits]], satisfies these requirements. — *end note*]
-The class template `basic_regex`, defined in Clause  [[re.regex]], needs
-a set of related types and functions to complete the definition of its
 semantics. These types and functions are provided as a set of member
 *typedef-name*s and functions in the template parameter `traits` used by
 the `basic_regex` class template. This subclause defines the semantics
 of these members.
 To specialize class template `basic_regex` for a character container
 `CharT` and its related regular expression traits class `Traits`, use
 `basic_regex<CharT, Traits>`.
-In Table  [[tab:re:RegexpTraits]] `X` denotes a traits class defining
-types and functions for the character container type `charT`; `u` is an
-object of type `X`; `v` is an object of type `const
 X`; `p` is a value of type `const charT*`; `I1` and `I2` are input
-iterators ([[input.iterators]]); `F1` and `F2` are forward iterators (
-[[forward.iterators]]); `c` is a value of type `const charT`; `s` is an
 object of type `X::string_type`; `cs` is an object of type
 `const X::string_type`; `b` is a value of type `bool`; `I` is a value of
 type `int`; `cl` is an object of type `X::char_class_type`, and `loc` is
 an object of type `X::locale_type`.
 [*Note 2*: The value of *I* will only be 8, 10, or 16. — *end note*]
-[*Note 3*: Class template `regex_traits` satisfies the requirements for
-a regular expression traits class when it is specialized for `char` or
 `wchar_t`. This class template is described in the header `<regex>`, and
-is described in Clause  [[re.traits]]. — *end note*]
 ## Header `<regex>` synopsis <a id="re.syn">[[re.syn]]</a>
 ``` cpp
-#include <initializer_list>
 namespace std {
   // [re.const], regex constants
   namespace regex_constants {
     using syntax_option_type = T1;
@@ -148,144 +149,33 @@ namespace std {
   // [re.submatch.op], sub_match non-member operators
   template<class BiIter>
     bool operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
   template<class BiIter>
- bool operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
-  template <class BiIter>
-    bool operator<(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
-  template <class BiIter>
-    bool operator<=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
-  template <class BiIter>
-    bool operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
-  template <class BiIter>
-    bool operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
-  template <class BiIter, class ST, class SA>
-    bool operator==(
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-      const sub_match<BiIter>& rhs);
-  template <class BiIter, class ST, class SA>
-    bool operator!=(
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-      const sub_match<BiIter>& rhs);
-  template <class BiIter, class ST, class SA>
-    bool operator<(
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-      const sub_match<BiIter>& rhs);
-  template <class BiIter, class ST, class SA>
-    bool operator>(
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-      const sub_match<BiIter>& rhs);
-  template <class BiIter, class ST, class SA>
-    bool operator>=(
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-      const sub_match<BiIter>& rhs);
-  template <class BiIter, class ST, class SA>
-    bool operator<=(
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-      const sub_match<BiIter>& rhs);
   template<class BiIter, class ST, class SA>
     bool operator==(
       const sub_match<BiIter>& lhs,
       const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
   template<class BiIter, class ST, class SA>
- bool operator!=(
       const sub_match<BiIter>& lhs,
       const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-  template <class BiIter, class ST, class SA>
-    bool operator<(
-      const sub_match<BiIter>& lhs,
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-  template <class BiIter, class ST, class SA>
-    bool operator>(
-      const sub_match<BiIter>& lhs,
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-  template <class BiIter, class ST, class SA>
-    bool operator>=(
-      const sub_match<BiIter>& lhs,
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-  template <class BiIter, class ST, class SA>
-    bool operator<=(
-      const sub_match<BiIter>& lhs,
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-  template <class BiIter>
-    bool operator==(const typename iterator_traits<BiIter>::value_type* lhs,
-                    const sub_match<BiIter>& rhs);
-  template <class BiIter>
-    bool operator!=(const typename iterator_traits<BiIter>::value_type* lhs,
-                    const sub_match<BiIter>& rhs);
-  template <class BiIter>
-    bool operator<(const typename iterator_traits<BiIter>::value_type* lhs,
-                   const sub_match<BiIter>& rhs);
-  template <class BiIter>
-    bool operator>(const typename iterator_traits<BiIter>::value_type* lhs,
-                   const sub_match<BiIter>& rhs);
-  template <class BiIter>
-    bool operator>=(const typename iterator_traits<BiIter>::value_type* lhs,
-                    const sub_match<BiIter>& rhs);
-  template <class BiIter>
-    bool operator<=(const typename iterator_traits<BiIter>::value_type* lhs,
-                    const sub_match<BiIter>& rhs);
   template<class BiIter>
     bool operator==(const sub_match<BiIter>& lhs,
                     const typename iterator_traits<BiIter>::value_type* rhs);
   template<class BiIter>
- bool operator!=(const sub_match<BiIter>& lhs,
-                    const typename iterator_traits<BiIter>::value_type* rhs);
-  template <class BiIter>
-    bool operator<(const sub_match<BiIter>& lhs,
-                   const typename iterator_traits<BiIter>::value_type* rhs);
-  template <class BiIter>
-    bool operator>(const sub_match<BiIter>& lhs,
-                   const typename iterator_traits<BiIter>::value_type* rhs);
-  template <class BiIter>
-    bool operator>=(const sub_match<BiIter>& lhs,
-                    const typename iterator_traits<BiIter>::value_type* rhs);
-  template <class BiIter>
-    bool operator<=(const sub_match<BiIter>& lhs,
                      const typename iterator_traits<BiIter>::value_type* rhs);
-  template <class BiIter>
-    bool operator==(const typename iterator_traits<BiIter>::value_type& lhs,
-                    const sub_match<BiIter>& rhs);
-  template <class BiIter>
-    bool operator!=(const typename iterator_traits<BiIter>::value_type& lhs,
-                    const sub_match<BiIter>& rhs);
-  template <class BiIter>
-    bool operator<(const typename iterator_traits<BiIter>::value_type& lhs,
-                   const sub_match<BiIter>& rhs);
-  template <class BiIter>
-    bool operator>(const typename iterator_traits<BiIter>::value_type& lhs,
-                   const sub_match<BiIter>& rhs);
-  template <class BiIter>
-    bool operator>=(const typename iterator_traits<BiIter>::value_type& lhs,
-                    const sub_match<BiIter>& rhs);
-  template <class BiIter>
-    bool operator<=(const typename iterator_traits<BiIter>::value_type& lhs,
-                    const sub_match<BiIter>& rhs);
   template<class BiIter>
     bool operator==(const sub_match<BiIter>& lhs,
                     const typename iterator_traits<BiIter>::value_type& rhs);
   template<class BiIter>
- bool operator!=(const sub_match<BiIter>& lhs,
-                    const typename iterator_traits<BiIter>::value_type& rhs);
-  template <class BiIter>
-    bool operator<(const sub_match<BiIter>& lhs,
-                   const typename iterator_traits<BiIter>::value_type& rhs);
-  template <class BiIter>
-    bool operator>(const sub_match<BiIter>& lhs,
-                   const typename iterator_traits<BiIter>::value_type& rhs);
-  template <class BiIter>
-    bool operator>=(const sub_match<BiIter>& lhs,
-                    const typename iterator_traits<BiIter>::value_type& rhs);
-  template <class BiIter>
-    bool operator<=(const sub_match<BiIter>& lhs,
                      const typename iterator_traits<BiIter>::value_type& rhs);
   template<class charT, class ST, class BiIter>
     basic_ostream<charT, ST>&
       operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
@@ -302,13 +192,10 @@ namespace std {
   // match_results comparisons
   template<class BidirectionalIterator, class Allocator>
     bool operator==(const match_results<BidirectionalIterator, Allocator>& m1,
                     const match_results<BidirectionalIterator, Allocator>& m2);
-  template <class BidirectionalIterator, class Allocator>
-    bool operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
-                    const match_results<BidirectionalIterator, Allocator>& m2);
   // [re.results.swap], match_results swap
   template<class BidirectionalIterator, class Allocator>
     void swap(match_results<BidirectionalIterator, Allocator>& m1,
               match_results<BidirectionalIterator, Allocator>& m2);
@@ -487,31 +374,31 @@ namespace std::regex_constants {
   inline constexpr syntax_option_type multiline = unspecified;
 }
 ```
 The type `syntax_option_type` is an *implementation-defined* bitmask
-type ([[bitmask.types]]). Setting its elements has the effects listed
-in Table  [[tab:re:syntaxoption]]. A valid value of type
-`syntax_option_type` shall have at most one of the grammar elements
-`ECMAScript`, `basic`, `extended`, `awk`, `grep`, `egrep`, set. If no
-grammar element is set, the default grammar is `ECMAScript`.
-**Table: `syntax_option_type` effects** <a id="tab:re:syntaxoption">[tab:re:syntaxoption]</a>
 | Element        | Effect(s) if set                                                                                                                                                                                                                                                                                                             |
-| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| % `icase`      | Specifies that matching of regular expressions against a character container sequence shall be performed without regard to case. \indexlibrary{\idxcode{syntax_option_type}!\idxcode{icase}}%                                                                                                                                             |
-| % `nosubs`     | Specifies that no sub-expressions shall be considered to be marked, so that when a regular expression is matched against a character container sequence, no sub-expression matches shall be stored in the supplied `match_results` structure. \indexlibrary{\idxcode{syntax_option_type}!\idxcode{nosubs}}% |
-| % `optimize`   | Specifies that the regular expression engine should pay more attention to the speed with which regular expressions are matched, and less to the speed with which regular expression objects are constructed. Otherwise it has no detectable effect on the program output. \indexlibrary{\idxcode{syntax_option_type}!\idxcode{optimize}}% |
-| % `collate`    | Specifies that character ranges of the form `"[a-b]"` shall be locale sensitive. \indexlibrary{\idxcode{syntax_option_type}!\idxcode{collate}}% \indextext{locale}%                                                                                                                                                                       |
-| % `ECMAScript` | Specifies that the grammar recognized by the regular expression engine shall be that used by ECMAScript in ECMA-262, as modified in~ [[re.grammar]]. \indextext{ECMAScript}% \indexlibrary{\idxcode{syntax_option_type}!\idxcode{ECMAScript}}% |
-| % `basic`      | Specifies that the grammar recognized by the regular expression engine shall be that used by basic regular expressions in POSIX, Base Definitions and Headers, Section 9, Regular Expressions. \indextext{POSIX!regular expressions}% \indexlibrary{\idxcode{syntax_option_type}!\idxcode{basic}}% |
-| % `extended`   | Specifies that the grammar recognized by the regular expression engine shall be that used by extended regular expressions in POSIX, Base Definitions and Headers, Section 9, Regular Expressions. \indextext{POSIX!extended regular expressions}% \indexlibrary{\idxcode{syntax_option_type}!\idxcode{extended}}% |
-| % `awk`        | Specifies that the grammar recognized by the regular expression engine shall be that used by the utility awk in POSIX. \indextext{\idxcode{awk}}% \indexlibrary{\idxcode{syntax_option_type}!\idxcode{awk}}%                                                                                                                              |
-| % `grep`       | Specifies that the grammar recognized by the regular expression engine shall be that used by the utility grep in POSIX. \indextext{\idxcode{grep}}% \indexlibrary{\idxcode{syntax_option_type}!\idxcode{grep}}%                                                                                                                           |
-| % `egrep`      | Specifies that the grammar recognized by the regular expression engine shall be that used by the utility grep when given the -E option in POSIX. \indextext{\idxcode{egrep}}% \indexlibrary{\idxcode{syntax_option_type}!\idxcode{egrep}}%                                                                                                |
-| % `multiline`  | Specifies that `\^` shall match the beginning of a line and `$` shall match the end of a line, if the `ECMAScript` engine is selected. \indextext{\idxcode{multiline}}% \indexlibrary{\idxcode{syntax_option_type}!\idxcode{multiline}}% |
 ### Bitmask type `match_flag_type` <a id="re.matchflag">[[re.matchflag]]</a>
 ``` cpp
@@ -531,37 +418,36 @@ namespace std::regex_constants {
   inline constexpr match_flag_type format_no_copy = unspecified;
   inline constexpr match_flag_type format_first_only = unspecified;
 }
 ```
-The type `match_flag_type` is an *implementation-defined* bitmask type (
-[[bitmask.types]]). The constants of that type, except for
 `match_default` and `format_default`, are bitmask elements. The
 `match_default` and `format_default` constants are empty bitmasks.
 Matching a regular expression against a sequence of characters
 \[`first`, `last`) proceeds according to the rules of the grammar
 specified for the regular expression object, modified according to the
-effects listed in Table  [[tab:re:matchflag]] for any bitmask elements
-set.
 **Table: `regex_constants::match_flag_type` effects when obtaining a match against a
-     character container sequence {[}`first`, `last`{)}.** <a id="tab:re:matchflag">[tab:re:matchflag]</a>
 | Element                                                       | Effect(s) if set                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| ----------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| % \indexlibrary{\idxcode{match_not_bol}}% `match_not_bol`         | The first character in the sequence {[}`first`, `last`{)} shall be treated as though it is not at the beginning of a line, so the character \verb|^| in the regular expression shall not match {[}`first`, `first`{)}.                                                                                                                                                                                                                                                      |
-| % \indexlibrary{\idxcode{match_not_eol}}% `match_not_eol`         | The last character in the sequence {[}`first`, `last`{)} shall be treated as though it is not at the end of a line, so the character \verb|"$"| in the regular expression shall not match {[}`last`, `last`{)}.                                                                                                                                                                                                                                                             |
-| % \indexlibrary{\idxcode{match_not_bow}}% `match_not_bow`         | The expression \verb|"b"| shall not match the sub-sequence {[}`first`, `first`{)}.                                                                                                                                                                                                                                                                                                                                                                                          |
-| % \indexlibrary{\idxcode{match_not_eow}}% `match_not_eow`         | The expression \verb|"b"| shall not match the sub-sequence {[}`last`, `last`{)}.                                                                                                                                                                                                                                                                                                                                                                                            |
-| % \indexlibrary{\idxcode{match_any}}% `match_any`                 | If more than one match is possible then any match is an acceptable result.                                                                                                                                                                                                                                                                                                                                                                                                  |
-| % \indexlibrary{\idxcode{match_not_null}}% `match_not_null`       | The expression shall not match an empty sequence.                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| % \indexlibrary{\idxcode{match_continuous}}% `match_continuous`   | The expression shall only match a sub-sequence that begins at `first`.                                                                                                                                                                                                                                                                                                                                                                                                      |
-| % \indexlibrary{\idxcode{match_prev_avail}}% `match_prev_avail`   | \verb!--first! is a valid iterator position. When this flag is set the flags `match_not_bol` and `match_not_bow` shall be ignored by the regular expression algorithms~([[re.alg]]) and iterators~([[re.iter]]). |
-| % \indexlibrary{\idxcode{format_default}}% `format_default`       | When a regular expression match is to be replaced by a new string, the new string shall be constructed using the rules used by the ECMAScript replace function in ECMA-262, part 15.5.4.11 String.prototype.replace. In addition, during search and replace operations all non-overlapping occurrences of the regular expression shall be located and replaced, and sections of the input that did not match the expression shall be copied unchanged to the output string. |
-| % \indexlibrary{\idxcode{format_sed}}% `format_sed`               | When a regular expression match is to be replaced by a new string, the new string shall be constructed using the rules used by the sed utility in POSIX.                                                                                                                                                                                                                                                                                                                    |
-| % \indexlibrary{\idxcode{format_no_copy}}% `format_no_copy`       | During a search and replace operation, sections of the character container sequence being searched that do not match the regular expression shall not be copied to the output string.                                                                                                                                                                                                                                                                                       |
-| % \indexlibrary{\idxcode{format_first_only}}% `format_first_only` | When specified during a search and replace operation, only the first occurrence of the regular expression shall be replaced.                                                                                                                                                                                                                                                                                                                                                |
 ### Implementation-defined `error_type` <a id="re.err">[[re.err]]</a>
 ``` cpp
@@ -581,15 +467,15 @@ namespace std::regex_constants {
   inline constexpr error_type error_complexity = unspecified;
   inline constexpr error_type error_stack = unspecified;
 }
 ```
-The type `error_type` is an *implementation-defined* enumerated type (
-[[enumerated.types]]). Values of type `error_type` represent the error
-conditions described in Table  [[tab:re:errortype]]:
-**Table: `error_type` values in the C locale** <a id="tab:re:errortype">[tab:re:errortype]</a>
 | Value                | Error condition                                                                                                         |
 | -------------------- | ----------------------------------------------------------------------------------------------------------------------- |
 | `error_collate`      | The expression contained an invalid collating element name.                                                             |
 | % `error_ctype`      | The expression contained an invalid character class name.                                                               |
@@ -621,13 +507,11 @@ to report errors from the regular expression library.
 ``` cpp
 regex_error(regex_constants::error_type ecode);
 ```
-*Effects:* Constructs an object of class `regex_error`.
-*Postconditions:* `ecode == code()`.
 ``` cpp
 regex_constants::error_type code() const;
 ```
@@ -640,11 +524,11 @@ namespace std {
   template<class charT>
     struct regex_traits {
       using char_type       = charT;
       using string_type     = basic_string<char_type>;
       using locale_type     = locale;
-      using char_class_type = {bitmask_type};
       regex_traits();
       static size_t length(const char_type* p);
       charT translate(charT c) const;
       charT translate_nocase(charT c) const;
@@ -666,12 +550,11 @@ namespace std {
     };
 }
 ```
 The specializations `regex_traits<char>` and `regex_traits<wchar_t>`
-shall be valid and shall satisfy the requirements for a regular
-expression traits class ([[re.req]]).
 ``` cpp
 using char_class_type = bitmask_type;
 ```
@@ -705,11 +588,11 @@ template <class ForwardIterator>
 *Effects:* As if by:
 ``` cpp
 string_type str(first, last);
 return use_facet<collate<charT>>(
-  getloc()).transform(&*str.begin(), &*str.begin() + str.length());
 ```
 ``` cpp
 template<class ForwardIterator>
   string_type transform_primary(ForwardIterator first, ForwardIterator last) const;
@@ -729,35 +612,35 @@ returns an empty string.
 ``` cpp
 template<class ForwardIterator>
   string_type lookup_collatename(ForwardIterator first, ForwardIterator last) const;
 ```
-*Returns:* a sequence of one or more characters that represents the
 collating element consisting of the character sequence designated by the
 iterator range \[`first`, `last`). Returns an empty string if the
 character sequence is not a valid collating element.
 ``` cpp
 template<class ForwardIterator>
   char_class_type lookup_classname(
     ForwardIterator first, ForwardIterator last, bool icase = false) const;
 ```
-*Returns:* an unspecified value that represents the character
 classification named by the character sequence designated by the
 iterator range \[`first`, `last`). If the parameter `icase` is `true`
 then the returned mask identifies the character classification without
 regard to the case of the characters being matched, otherwise it does
 honor the case of the characters being matched.[^1] The value returned
 shall be independent of the case of the characters in the character
 sequence. If the name is not recognized then returns
 `char_class_type()`.
 *Remarks:* For `regex_traits<char>`, at least the narrow character names
-in Table  [[tab:re.traits.classnames]] shall be recognized. For
 `regex_traits<wchar_t>`, at least the wide character names in
-Table  [[tab:re.traits.classnames]] shall be recognized.
 ``` cpp
 bool isctype(charT c, char_class_type f) const;
 ```
@@ -771,13 +654,12 @@ classification represented by `f`.
 template<class C>
   ctype_base::mask convert(typename regex_traits<C>::char_class_type f);
 ```
 that returns a value in which each `ctype_base::mask` value
-corresponding to a value in `f` named in
-Table  [[tab:re.traits.classnames]] is set, then the result is
-determined as if by:
 ``` cpp
 ctype_base::mask m = convert<charT>(f);
 const ctype<charT>& ct = use_facet<ctype<charT>>(getloc());
 if (ct.is(m, c)) {
@@ -821,13 +703,13 @@ t.isctype(' ', f); // returns false
 ``` cpp
 int value(charT ch, int radix) const;
 ```
-*Requires:* The value of `radix` shall be 8, 10, or 16.
-*Returns:* the value represented by the digit `ch` in base `radix` if
 the character `ch` is a valid digit in base `radix`; otherwise returns
 `-1`.
 ``` cpp
 locale_type imbue(locale_type loc);
@@ -837,25 +719,25 @@ locale_type imbue(locale_type loc);
 [*Note 1*: Calling `imbue` with a different locale than the one
 currently in use invalidates all cached data held by
 `*this`. — *end note*]
-*Returns:* if no locale has been previously imbued then a copy of the
 global locale in effect at the time of construction of `*this`,
 otherwise a copy of the last argument passed to `imbue`.
-*Postconditions:* `getloc() == loc`.
 ``` cpp
 locale_type getloc() const;
 ```
-*Returns:* if no locale has been imbued then a copy of the global locale
 in effect at the time of construction of `*this`, otherwise a copy of
 the last argument passed to `imbue`.
-**Table: Character class names and corresponding `ctype` masks** <a id="tab:re.traits.classnames">[tab:re.traits.classnames]</a>
 | Narrow character name | Wide character name | Corresponding `ctype_base::mask` value |
 | --------------------- | ------------------- | -------------------------------------- |
 | `"alnum"`             | `L"alnum"`          | `ctype_base::alnum`                    |
 | `"alpha"`             | `L"alpha"`          | `ctype_base::alpha`                    |
@@ -888,87 +770,76 @@ converting the sequence of `charT` objects to an internal
 representation. It is not specified what form this representation takes,
 nor how it is accessed by algorithms that operate on regular
 expressions.
 [*Note 1*: Implementations will typically declare some function
-templates as friends of `basic_regex` to achieve this — *end note*]
 The functions described in this Clause report errors by throwing
 exceptions of type `regex_error`.
 ``` cpp
 namespace std {
   template<class charT, class traits = regex_traits<charT>>
     class basic_regex {
     public:
-      // types:
       using value_type  =          charT;
       using traits_type =          traits;
       using string_type = typename traits::string_type;
       using flag_type   =          regex_constants::syntax_option_type;
       using locale_type = typename traits::locale_type;
-      // [re.regex.const], constants
-      static constexpr regex_constants::syntax_option_type
-        icase = regex_constants::icase;
-      static constexpr regex_constants::syntax_option_type
-        nosubs = regex_constants::nosubs;
-      static constexpr regex_constants::syntax_option_type
-        optimize = regex_constants::optimize;
-      static constexpr regex_constants::syntax_option_type
-        collate = regex_constants::collate;
-      static constexpr regex_constants::syntax_option_type
-        ECMAScript = regex_constants::ECMAScript;
-      static constexpr regex_constants::syntax_option_type
-        basic = regex_constants::basic;
-      static constexpr regex_constants::syntax_option_type
-        extended = regex_constants::extended;
-      static constexpr regex_constants::syntax_option_type
-        awk = regex_constants::awk;
-      static constexpr regex_constants::syntax_option_type
-        grep = regex_constants::grep;
-      static constexpr regex_constants::syntax_option_type
-        egrep = regex_constants::egrep;
-      static constexpr regex_constants::syntax_option_type
-        multiline = regex_constants::multiline;
       // [re.regex.construct], construct/copy/destroy
       basic_regex();
       explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript);
       basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript);
       basic_regex(const basic_regex&);
       basic_regex(basic_regex&&) noexcept;
       template<class ST, class SA>
-        explicit basic_regex(const basic_string<charT, ST, SA>& p,
                              flag_type f = regex_constants::ECMAScript);
       template<class ForwardIterator>
         basic_regex(ForwardIterator first, ForwardIterator last,
                     flag_type f = regex_constants::ECMAScript);
-      basic_regex(initializer_list<charT>, flag_type = regex_constants::ECMAScript);
       ~basic_regex();
-      basic_regex& operator=(const basic_regex&);
-      basic_regex& operator=(basic_regex&&) noexcept;
-      basic_regex& operator=(const charT* ptr);
-      basic_regex& operator=(initializer_list<charT> il);
-      template <class ST, class SA>
-        basic_regex& operator=(const basic_string<charT, ST, SA>& p);
       // [re.regex.assign], assign
-      basic_regex& assign(const basic_regex& that);
-      basic_regex& assign(basic_regex&& that) noexcept;
-      basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
-      basic_regex& assign(const charT* p, size_t len, flag_type f);
-      template <class string_traits, class A>
-        basic_regex& assign(const basic_string<charT, string_traits, A>& s,
                             flag_type f = regex_constants::ECMAScript);
       template<class InputIterator>
         basic_regex& assign(InputIterator first, InputIterator last,
                             flag_type f = regex_constants::ECMAScript);
       basic_regex& assign(initializer_list<charT>,
-                          flag_type = regex_constants::ECMAScript);
       // [re.regex.operations], const operations
       unsigned mark_count() const;
       flag_type flags() const;
@@ -985,239 +856,198 @@ namespace std {
                 regex_constants::syntax_option_type = regex_constants::ECMAScript)
       -> basic_regex<typename iterator_traits<ForwardIterator>::value_type>;
 }
 ```
-### `basic_regex` constants <a id="re.regex.const">[[re.regex.const]]</a>
-``` cpp
-static constexpr regex_constants::syntax_option_type icase = regex_constants::icase;
-static constexpr regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
-static constexpr regex_constants::syntax_option_type optimize = regex_constants::optimize;
-static constexpr regex_constants::syntax_option_type collate = regex_constants::collate;
-static constexpr regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
-static constexpr regex_constants::syntax_option_type basic = regex_constants::basic;
-static constexpr regex_constants::syntax_option_type extended = regex_constants::extended;
-static constexpr regex_constants::syntax_option_type awk = regex_constants::awk;
-static constexpr regex_constants::syntax_option_type grep = regex_constants::grep;
-static constexpr regex_constants::syntax_option_type egrep = regex_constants::egrep;
-static constexpr regex_constants::syntax_option_type multiline = regex_constants::multiline;
-```
-The static constant members are provided as synonyms for the constants
-declared in namespace `regex_constants`.
-### `basic_regex` constructors <a id="re.regex.construct">[[re.regex.construct]]</a>
 ``` cpp
 basic_regex();
 ```
-*Effects:* Constructs an object of class `basic_regex` that does not
-match any character sequence.
 ``` cpp
 explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript);
 ```
-*Requires:* `p` shall not be a null pointer.
-*Throws:* `regex_error` if `p` is not a valid regular expression.
-*Effects:* Constructs an object of class `basic_regex`; the object’s
-internal finite state machine is constructed from the regular expression
-contained in the array of `charT` of length
-`char_traits<charT>::length(p)` whose first element is designated by
-`p`, and interpreted according to the flags `f`.
-*Postconditions:* `flags()` returns `f`. `mark_count()` returns the
-number of marked sub-expressions within the expression.
 ``` cpp
-basic_regex(const charT* p, size_t len, flag_type f);
 ```
-*Requires:* `p` shall not be a null pointer.
-*Throws:* `regex_error` if `p` is not a valid regular expression.
-*Effects:* Constructs an object of class `basic_regex`; the object’s
-internal finite state machine is constructed from the regular expression
-contained in the sequence of characters \[`p`, `p+len`), and interpreted
-according the flags specified in `f`.
-*Postconditions:* `flags()` returns `f`. `mark_count()` returns the
-number of marked sub-expressions within the expression.
 ``` cpp
 basic_regex(const basic_regex& e);
 ```
-*Effects:* Constructs an object of class `basic_regex` as a copy of the
-object `e`.
-*Postconditions:* `flags()` and `mark_count()` return `e.flags()` and
 `e.mark_count()`, respectively.
 ``` cpp
 basic_regex(basic_regex&& e) noexcept;
 ```
-*Effects:* Move constructs an object of class `basic_regex` from `e`.
-*Postconditions:* `flags()` and `mark_count()` return the values that
 `e.flags()` and `e.mark_count()`, respectively, had before construction.
-`e` is in a valid state with unspecified value.
 ``` cpp
 template<class ST, class SA>
   explicit basic_regex(const basic_string<charT, ST, SA>& s,
                        flag_type f = regex_constants::ECMAScript);
 ```
 *Throws:* `regex_error` if `s` is not a valid regular expression.
-*Effects:* Constructs an object of class `basic_regex`; the object’s
-internal finite state machine is constructed from the regular expression
-contained in the string `s`, and interpreted according to the flags
-specified in `f`.
-*Postconditions:* `flags()` returns `f`. `mark_count()` returns the
-number of marked sub-expressions within the expression.
 ``` cpp
 template<class ForwardIterator>
   basic_regex(ForwardIterator first, ForwardIterator last,
               flag_type f = regex_constants::ECMAScript);
 ```
 *Throws:* `regex_error` if the sequence \[`first`, `last`) is not a
 valid regular expression.
-*Effects:* Constructs an object of class `basic_regex`; the object’s
-internal finite state machine is constructed from the regular expression
-contained in the sequence of characters \[`first`, `last`), and
-interpreted according to the flags specified in `f`.
-*Postconditions:* `flags()` returns `f`. `mark_count()` returns the
-number of marked sub-expressions within the expression.
 ``` cpp
 basic_regex(initializer_list<charT> il, flag_type f = regex_constants::ECMAScript);
 ```
 *Effects:* Same as `basic_regex(il.begin(), il.end(), f)`.
-### `basic_regex` assign <a id="re.regex.assign">[[re.regex.assign]]</a>
 ``` cpp
 basic_regex& operator=(const basic_regex& e);
 ```
-*Effects:* Copies `e` into `*this` and returns `*this`.
-*Postconditions:* `flags()` and `mark_count()` return `e.flags()` and
 `e.mark_count()`, respectively.
 ``` cpp
 basic_regex& operator=(basic_regex&& e) noexcept;
 ```
-*Effects:* Move assigns from `e` into `*this` and returns `*this`.
-*Postconditions:* `flags()` and `mark_count()` return the values that
 `e.flags()` and `e.mark_count()`, respectively, had before assignment.
 `e` is in a valid state with unspecified value.
 ``` cpp
-basic_regex& operator=(const charT* ptr);
 ```
-*Requires:* `ptr` shall not be a null pointer.
-*Effects:* Returns `assign(ptr)`.
 ``` cpp
 basic_regex& operator=(initializer_list<charT> il);
 ```
-*Effects:* Returns `assign(il.begin(), il.end())`.
 ``` cpp
 template<class ST, class SA>
-  basic_regex& operator=(const basic_string<charT, ST, SA>& p);
 ```
-*Effects:* Returns `assign(p)`.
 ``` cpp
-basic_regex& assign(const basic_regex& that);
 ```
-*Effects:* Equivalent to `*this = that`.
-*Returns:* `*this`.
 ``` cpp
-basic_regex& assign(basic_regex&& that) noexcept;
 ```
-*Effects:* Equivalent to `*this = std::move(that)`.
-*Returns:* `*this`.
 ``` cpp
-basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
 ```
-*Returns:* `assign(string_type(ptr), f)`.
 ``` cpp
-basic_regex& assign(const charT* ptr, size_t len, flag_type f = regex_constants::ECMAScript);
 ```
-*Returns:* `assign(string_type(ptr, len), f)`.
 ``` cpp
-template <class string_traits, class A>
-  basic_regex& assign(const basic_string<charT, string_traits, A>& s,
                       flag_type f = regex_constants::ECMAScript);
 ```
-*Throws:* `regex_error` if `s` is not a valid regular expression.
 *Returns:* `*this`.
 *Effects:* Assigns the regular expression contained in the string `s`,
 interpreted according the flags specified in `f`. If an exception is
 thrown, `*this` is unchanged.
-*Postconditions:* If no exception is thrown, `flags()` returns `f` and
 `mark_count()` returns the number of marked sub-expressions within the
 expression.
 ``` cpp
 template<class InputIterator>
   basic_regex& assign(InputIterator first, InputIterator last,
                       flag_type f = regex_constants::ECMAScript);
 ```
-*Requires:* The type `InputIterator` shall satisfy the requirements for
-an Input Iterator ([[input.iterators]]).
-*Returns:* `assign(string_type(first, last), f)`.
 ``` cpp
 basic_regex& assign(initializer_list<charT> il,
                     flag_type f = regex_constants::ECMAScript);
 ```
-*Effects:* Same as `assign(il.begin(), il.end(), f)`.
-*Returns:* `*this`.
-### `basic_regex` constant operations <a id="re.regex.operations">[[re.regex.operations]]</a>
 ``` cpp
 unsigned mark_count() const;
 ```
@@ -1229,11 +1059,11 @@ flag_type flags() const;
 ```
 *Effects:* Returns a copy of the regular expression syntax flags that
 were passed to the object’s constructor or to the last call to `assign`.
-### `basic_regex` locale <a id="re.regex.locale">[[re.regex.locale]]</a>
 ``` cpp
 locale_type imbue(locale_type loc);
 ```
@@ -1248,26 +1078,24 @@ locale_type getloc() const;
 *Effects:* Returns the result of `traits_inst.getloc()` where
 `traits_inst` is a (default-initialized) instance of the template
 parameter `traits` stored within the object.
-### `basic_regex` swap <a id="re.regex.swap">[[re.regex.swap]]</a>
 ``` cpp
 void swap(basic_regex& e);
 ```
 *Effects:* Swaps the contents of the two regular expressions.
-*Postconditions:* `*this` contains the regular expression that was in
-`e`, `e` contains the regular expression that was in `*this`.
 *Complexity:* Constant time.
-### `basic_regex` non-member functions <a id="re.regex.nonmemb">[[re.regex.nonmemb]]</a>
-#### `basic_regex` non-member swap <a id="re.regex.nmswap">[[re.regex.nmswap]]</a>
 ``` cpp
 template<class charT, class traits>
   void swap(basic_regex<charT, traits>& lhs, basic_regex<charT, traits>& rhs);
 ```
@@ -1304,11 +1132,11 @@ namespace std {
       int compare(const value_type* s) const;
     };
 }
 ```
-### `sub_match` members <a id="re.submatch.members">[[re.submatch.members]]</a>
 ``` cpp
 constexpr sub_match();
 ```
@@ -1349,115 +1177,31 @@ int compare(const string_type& s) const;
 int compare(const value_type* s) const;
 ```
 *Returns:* `str().compare(s)`.
-### `sub_match` non-member operators <a id="re.submatch.op">[[re.submatch.op]]</a>
 ``` cpp
 template<class BiIter>
   bool operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 ```
 *Returns:* `lhs.compare(rhs) == 0`.
 ``` cpp
 template<class BiIter>
- bool operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 ```
-*Returns:* `lhs.compare(rhs) != 0`.
-``` cpp
-template <class BiIter>
-  bool operator<(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
-```
-*Returns:* `lhs.compare(rhs) < 0`.
-``` cpp
-template <class BiIter>
-  bool operator<=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
-```
-*Returns:* `lhs.compare(rhs) <= 0`.
-``` cpp
-template <class BiIter>
-  bool operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
-```
-*Returns:* `lhs.compare(rhs) >= 0`.
-``` cpp
-template <class BiIter>
-  bool operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
-```
-*Returns:* `lhs.compare(rhs) > 0`.
-``` cpp
-template <class BiIter, class ST, class SA>
-  bool operator==(
-    const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-    const sub_match<BiIter>& rhs);
-```
-*Returns:*
-``` cpp
-rhs.compare(typename sub_match<BiIter>::string_type(lhs.data(), lhs.size())) == 0
-```
-``` cpp
-template <class BiIter, class ST, class SA>
-  bool operator!=(
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-      const sub_match<BiIter>& rhs);
-```
-*Returns:* `!(lhs == rhs)`.
-``` cpp
-template <class BiIter, class ST, class SA>
-  bool operator<(
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-      const sub_match<BiIter>& rhs);
-```
-*Returns:*
-``` cpp
-rhs.compare(typename sub_match<BiIter>::string_type(lhs.data(), lhs.size())) > 0
-```
-``` cpp
-template <class BiIter, class ST, class SA>
-  bool operator>(
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-      const sub_match<BiIter>& rhs);
-```
-*Returns:* `rhs < lhs`.
-``` cpp
-template <class BiIter, class ST, class SA>
-  bool operator>=(
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-      const sub_match<BiIter>& rhs);
-```
-*Returns:* `!(lhs < rhs)`.
-``` cpp
-template <class BiIter, class ST, class SA>
-  bool operator<=(
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-      const sub_match<BiIter>& rhs);
-```
-*Returns:* `!(rhs < lhs)`.
 ``` cpp
 template<class BiIter, class ST, class SA>
   bool operator==(
       const sub_match<BiIter>& lhs,
@@ -1470,202 +1214,39 @@ template <class BiIter, class ST, class SA>
 lhs.compare(typename sub_match<BiIter>::string_type(rhs.data(), rhs.size())) == 0
 ```
 ``` cpp
 template<class BiIter, class ST, class SA>
- bool operator!=(
-      const sub_match<BiIter>& lhs,
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-```
-*Returns:* `!(lhs == rhs)`.
-``` cpp
-template <class BiIter, class ST, class SA>
-  bool operator<(
       const sub_match<BiIter>& lhs,
       const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 ```
 *Returns:*
 ``` cpp
-lhs.compare(typename sub_match<BiIter>::string_type(rhs.data(), rhs.size())) < 0
 ```
-``` cpp
-template <class BiIter, class ST, class SA>
-  bool operator>(
-      const sub_match<BiIter>& lhs,
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-```
-*Returns:* `rhs < lhs`.
-``` cpp
-template <class BiIter, class ST, class SA>
-  bool operator>=(
-      const sub_match<BiIter>& lhs,
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-```
-*Returns:* `!(lhs < rhs)`.
-``` cpp
-template <class BiIter, class ST, class SA>
-  bool operator<=(
-      const sub_match<BiIter>& lhs,
-      const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-```
-*Returns:* `!(rhs < lhs)`.
-``` cpp
-template <class BiIter>
-  bool operator==(const typename iterator_traits<BiIter>::value_type* lhs,
-                  const sub_match<BiIter>& rhs);
-```
-*Returns:* `rhs.compare(lhs) == 0`.
-``` cpp
-template <class BiIter>
-  bool operator!=(const typename iterator_traits<BiIter>::value_type* lhs,
-                  const sub_match<BiIter>& rhs);
-```
-*Returns:* `!(lhs == rhs)`.
-``` cpp
-template <class BiIter>
-  bool operator<(const typename iterator_traits<BiIter>::value_type* lhs,
-                 const sub_match<BiIter>& rhs);
-```
-*Returns:* `rhs.compare(lhs) > 0`.
-``` cpp
-template <class BiIter>
-  bool operator>(const typename iterator_traits<BiIter>::value_type* lhs,
-                 const sub_match<BiIter>& rhs);
-```
-*Returns:* `rhs < lhs`.
-``` cpp
-template <class BiIter>
-  bool operator>=(const typename iterator_traits<BiIter>::value_type* lhs,
-                  const sub_match<BiIter>& rhs);
-```
-*Returns:* `!(lhs < rhs)`.
-``` cpp
-template <class BiIter>
-  bool operator<=(const typename iterator_traits<BiIter>::value_type* lhs,
-                  const sub_match<BiIter>& rhs);
-```
-*Returns:* `!(rhs < lhs)`.
 ``` cpp
 template<class BiIter>
   bool operator==(const sub_match<BiIter>& lhs,
                   const typename iterator_traits<BiIter>::value_type* rhs);
 ```
 *Returns:* `lhs.compare(rhs) == 0`.
 ``` cpp
 template<class BiIter>
- bool operator!=(const sub_match<BiIter>& lhs,
                    const typename iterator_traits<BiIter>::value_type* rhs);
 ```
-*Returns:* `!(lhs == rhs)`.
-``` cpp
-template <class BiIter>
-  bool operator<(const sub_match<BiIter>& lhs,
-                 const typename iterator_traits<BiIter>::value_type* rhs);
-```
-*Returns:* `lhs.compare(rhs) < 0`.
-``` cpp
-template <class BiIter>
-  bool operator>(const sub_match<BiIter>& lhs,
-                 const typename iterator_traits<BiIter>::value_type* rhs);
-```
-*Returns:* `rhs < lhs`.
-``` cpp
-template <class BiIter>
-  bool operator>=(const sub_match<BiIter>& lhs,
-                  const typename iterator_traits<BiIter>::value_type* rhs);
-```
-*Returns:* `!(lhs < rhs)`.
-``` cpp
-template <class BiIter>
-  bool operator<=(const sub_match<BiIter>& lhs,
-                  const typename iterator_traits<BiIter>::value_type* rhs);
-```
-*Returns:* `!(rhs < lhs)`.
-``` cpp
-template <class BiIter>
-  bool operator==(const typename iterator_traits<BiIter>::value_type& lhs,
-                  const sub_match<BiIter>& rhs);
-```
-*Returns:*
-`rhs.compare(typename sub_match<BiIter>::string_type(1, lhs)) == 0`.
-``` cpp
-template <class BiIter>
-  bool operator!=(const typename iterator_traits<BiIter>::value_type& lhs,
-                  const sub_match<BiIter>& rhs);
-```
-*Returns:* `!(lhs == rhs)`.
-``` cpp
-template <class BiIter>
-  bool operator<(const typename iterator_traits<BiIter>::value_type& lhs,
-                 const sub_match<BiIter>& rhs);
-```
-*Returns:*
-`rhs.compare(typename sub_match<BiIter>::string_type(1, lhs)) > 0`.
-``` cpp
-template <class BiIter>
-  bool operator>(const typename iterator_traits<BiIter>::value_type& lhs,
-                 const sub_match<BiIter>& rhs);
-```
-*Returns:* `rhs < lhs`.
-``` cpp
-template <class BiIter>
-  bool operator>=(const typename iterator_traits<BiIter>::value_type& lhs,
-                  const sub_match<BiIter>& rhs);
-```
-*Returns:* `!(lhs < rhs)`.
-``` cpp
-template <class BiIter>
-  bool operator<=(const typename iterator_traits<BiIter>::value_type& lhs,
-                  const sub_match<BiIter>& rhs);
-```
-*Returns:* `!(rhs < lhs)`.
 ``` cpp
 template<class BiIter>
   bool operator==(const sub_match<BiIter>& lhs,
                   const typename iterator_traits<BiIter>::value_type& rhs);
@@ -1674,49 +1255,23 @@ template <class BiIter>
 *Returns:*
 `lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) == 0`.
 ``` cpp
 template<class BiIter>
- bool operator!=(const sub_match<BiIter>& lhs,
-                  const typename iterator_traits<BiIter>::value_type& rhs);
-```
-*Returns:* `!(lhs == rhs)`.
-``` cpp
-template <class BiIter>
-  bool operator<(const sub_match<BiIter>& lhs,
                    const typename iterator_traits<BiIter>::value_type& rhs);
 ```
 *Returns:*
-`lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) < 0`.
 ``` cpp
-template <class BiIter>
-  bool operator>(const sub_match<BiIter>& lhs,
-                 const typename iterator_traits<BiIter>::value_type& rhs);
 ```
-*Returns:* `rhs < lhs`.
-``` cpp
-template <class BiIter>
-  bool operator>=(const sub_match<BiIter>& lhs,
-                  const typename iterator_traits<BiIter>::value_type& rhs);
-```
-*Returns:* `!(lhs < rhs)`.
-``` cpp
-template <class BiIter>
-  bool operator<=(const sub_match<BiIter>& lhs,
-                  const typename iterator_traits<BiIter>::value_type& rhs);
-```
-*Returns:* `!(rhs < lhs)`.
 ``` cpp
 template<class charT, class ST, class BiIter>
   basic_ostream<charT, ST>&
     operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
 ```
@@ -1728,16 +1283,17 @@ template <class charT, class ST, class BiIter>
 Class template `match_results` denotes a collection of character
 sequences representing the result of a regular expression match. Storage
 for the collection is allocated and freed as necessary by the member
 functions of class template `match_results`.
-The class template `match_results` satisfies the requirements of an
 allocator-aware container and of a sequence container (
 [[container.requirements.general]], [[sequence.reqmts]]) except that
-only operations defined for const-qualified sequence containers are
-supported and that the semantics of comparison functions are different
-from those required for a container.
 A default-constructed `match_results` object has no fully established
 result state. A match result is *ready* when, as a consequence of a
 completed regular expression match modifying such an object, its result
 state becomes fully established. The effects of calling most member
@@ -1775,11 +1331,12 @@ namespace std {
       using char_type       =
               typename iterator_traits<BidirectionalIterator>::value_type;
       using string_type     = basic_string<char_type>;
       // [re.results.const], construct/copy/destroy
- explicit match_results(const Allocator& a = Allocator());
       match_results(const match_results& m);
       match_results(match_results&& m) noexcept;
       match_results& operator=(const match_results& m);
       match_results& operator=(match_results&& m);
       ~match_results();
@@ -1788,11 +1345,11 @@ namespace std {
       bool ready() const;
       // [re.results.size], size
       size_type size() const;
       size_type max_size() const;
-      bool empty() const;
       // [re.results.acc], element access
       difference_type length(size_type sub = 0) const;
       difference_type position(size_type sub = 0) const;
       string_type str(size_type sub = 0) const;
@@ -1831,57 +1388,40 @@ namespace std {
       void swap(match_results& that);
     };
 }
 ```
-### `match_results` constructors <a id="re.results.const">[[re.results.const]]</a>
-In all `match_results` constructors, a copy of the `Allocator` argument
-shall be used for any memory allocation performed by the constructor or
-member functions during the lifetime of the object.
-``` cpp
-match_results(const Allocator& a = Allocator());
-```
-*Effects:* Constructs an object of class `match_results`.
-*Postconditions:* `ready()` returns `false`. `size()` returns `0`.
 ``` cpp
-match_results(const match_results& m);
 ```
-*Effects:* Constructs an object of class `match_results`, as a copy of
-`m`.
 ``` cpp
 match_results(match_results&& m) noexcept;
 ```
-*Effects:*  Move constructs an object of class `match_results` from `m`
-satisfying the same postconditions as Table  [[tab:re:results:assign]].
-Additionally, the stored `Allocator` value is move constructed from
 `m.get_allocator()`.
-*Throws:* Nothing.
 ``` cpp
 match_results& operator=(const match_results& m);
 ```
-*Effects:* Assigns `m` to `*this`. The postconditions of this function
-are indicated in Table  [[tab:re:results:assign]].
 ``` cpp
 match_results& operator=(match_results&& m);
 ```
-*Effects:*  Move-assigns `m` to `*this`. The postconditions of this
-function are indicated in Table  [[tab:re:results:assign]].
-**Table: `match_results` assignment operator effects** <a id="tab:re:results:assign">[tab:re:results:assign]</a>
 | Element       | Value                                           |
 | ------------- | ----------------------------------------------- |
 | `ready()`     | `m.ready()`                                     |
 | `size()`      | `m.size()`                                      |
@@ -1891,20 +1431,20 @@ function are indicated in Table  [[tab:re:results:assign]].
 | `(*this)[n]`  | `m[n]` for all integers `n < m.size()`          |
 | `length(n)`   | `m.length(n)` for all integers `n < m.size()`   |
 | `position(n)` | `m.position(n)` for all integers `n < m.size()` |
-### `match_results` state <a id="re.results.state">[[re.results.state]]</a>
 ``` cpp
 bool ready() const;
 ```
 *Returns:* `true` if `*this` has a fully established result state,
 otherwise `false`.
-### `match_results` size <a id="re.results.size">[[re.results.size]]</a>
 ``` cpp
 size_type size() const;
 ```
@@ -1912,58 +1452,58 @@ size_type size() const;
 expression that was matched if `*this` represents the result of a
 successful match. Otherwise returns `0`.
 [*Note 1*: The state of a `match_results` object can be modified only
 by passing that object to `regex_match` or `regex_search`.
-Sections  [[re.alg.match]] and  [[re.alg.search]] specify the effects of
-those algorithms on their `match_results` arguments. — *end note*]
 ``` cpp
 size_type max_size() const;
 ```
 *Returns:* The maximum number of `sub_match` elements that can be stored
 in `*this`.
 ``` cpp
-bool empty() const;
 ```
 *Returns:* `size() == 0`.
-### `match_results` element access <a id="re.results.acc">[[re.results.acc]]</a>
 ``` cpp
 difference_type length(size_type sub = 0) const;
 ```
-*Requires:* `ready() == true`.
 *Returns:* `(*this)[sub].length()`.
 ``` cpp
 difference_type position(size_type sub = 0) const;
 ```
-*Requires:* `ready() == true`.
 *Returns:* The distance from the start of the target sequence to
 `(*this)[sub].first`.
 ``` cpp
 string_type str(size_type sub = 0) const;
 ```
-*Requires:* `ready() == true`.
 *Returns:* `string_type((*this)[sub])`.
 ``` cpp
 const_reference operator[](size_type n) const;
 ```
-*Requires:* `ready() == true`.
 *Returns:* A reference to the `sub_match` object representing the
 character sequence that matched marked sub-expression `n`. If `n == 0`
 then returns a reference to a `sub_match` object representing the
 character sequence that matched the whole regular expression. If
@@ -1972,21 +1512,21 @@ unmatched sub-expression.
 ``` cpp
 const_reference prefix() const;
 ```
-*Requires:* `ready() == true`.
 *Returns:* A reference to the `sub_match` object representing the
 character sequence from the start of the string being matched/searched
 to the start of the match found.
 ``` cpp
 const_reference suffix() const;
 ```
-*Requires:* `ready() == true`.
 *Returns:* A reference to the `sub_match` object representing the
 character sequence from the end of the match found to the end of the
 string being matched/searched.
@@ -2004,22 +1544,22 @@ const_iterator cend() const;
 ```
 *Returns:* A terminating iterator that enumerates over all the
 sub-expressions stored in `*this`.
-### `match_results` formatting <a id="re.results.form">[[re.results.form]]</a>
 ``` cpp
 template<class OutputIter>
   OutputIter format(
       OutputIter out,
       const char_type* fmt_first, const char_type* fmt_last,
       regex_constants::match_flag_type flags = regex_constants::format_default) const;
 ```
-*Requires:* `ready() == true` and `OutputIter` shall satisfy the
-requirements for an Output Iterator ([[output.iterators]]).
 *Effects:* Copies the character sequence \[`fmt_first`, `fmt_last`) to
 OutputIter `out`. Replaces each format specifier or escape sequence in
 the copied range with either the character(s) it represents or the
 sequence of characters within `*this` to which it refers. The bitmasks
@@ -2047,11 +1587,11 @@ template <class ST, class SA>
   basic_string<char_type, ST, SA> format(
       const basic_string<char_type, ST, SA>& fmt,
       regex_constants::match_flag_type flags = regex_constants::format_default) const;
 ```
-*Requires:* `ready() == true`.
 *Effects:* Constructs an empty string `result` of type
 `basic_string<char_type, ST, SA>` and calls:
 ``` cpp
@@ -2064,42 +1604,42 @@ format(back_inserter(result), fmt, flags);
 string_type format(
     const char_type* fmt,
     regex_constants::match_flag_type flags = regex_constants::format_default) const;
 ```
-*Requires:* `ready() == true`.
 *Effects:* Constructs an empty string `result` of type `string_type` and
 calls:
 ``` cpp
 format(back_inserter(result), fmt, fmt + char_traits<char_type>::length(fmt), flags);
 ```
 *Returns:* `result`.
-### `match_results` allocator <a id="re.results.all">[[re.results.all]]</a>
 ``` cpp
 allocator_type get_allocator() const;
 ```
 *Returns:* A copy of the Allocator that was passed to the object’s
 constructor or, if that allocator has been replaced, a copy of the most
 recent replacement.
-### `match_results` swap <a id="re.results.swap">[[re.results.swap]]</a>
 ``` cpp
 void swap(match_results& that);
 ```
 *Effects:* Swaps the contents of the two sequences.
-*Postconditions:* `*this` contains the sequence of matched
-sub-expressions that were in `that`, `that` contains the sequence of
-matched sub-expressions that were in `*this`.
 *Complexity:* Constant time.
 ``` cpp
 template<class BidirectionalIterator, class Allocator>
@@ -2107,11 +1647,11 @@ template <class BidirectionalIterator, class Allocator>
             match_results<BidirectionalIterator, Allocator>& m2);
 ```
 *Effects:* As if by `m1.swap(m2)`.
-### `match_results` non-member functions <a id="re.results.nonmember">[[re.results.nonmember]]</a>
 ``` cpp
 template<class BidirectionalIterator, class Allocator>
 bool operator==(const match_results<BidirectionalIterator, Allocator>& m1,
                 const match_results<BidirectionalIterator, Allocator>& m2);
@@ -2128,27 +1668,19 @@ returns `true` only if:
   - `m1.size() == m2.size() && equal(m1.begin(), m1.end(), m2.begin())`,
     and
   - `m1.suffix() == m2.suffix()`.
 [*Note 1*: The algorithm `equal` is defined in
-Clause  [[algorithms]]. — *end note*]
-``` cpp
-template <class BidirectionalIterator, class Allocator>
-bool operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
-                const match_results<BidirectionalIterator, Allocator>& m2);
-```
-*Returns:* `!(m1 == m2)`.
 ## Regular expression algorithms <a id="re.alg">[[re.alg]]</a>
 ### Exceptions <a id="re.except">[[re.except]]</a>
-The algorithms described in this subclause may throw an exception of
-type `regex_error`. If such an exception `e` is thrown, `e.code()` shall
-return either `regex_constants::error_complexity` or
 `regex_constants::error_stack`.
 ### `regex_match` <a id="re.alg.match">[[re.alg.match]]</a>
 ``` cpp
@@ -2157,12 +1689,12 @@ template <class BidirectionalIterator, class Allocator, class charT, class trait
                    match_results<BidirectionalIterator, Allocator>& m,
                    const basic_regex<charT, traits>& e,
                    regex_constants::match_flag_type flags = regex_constants::match_default);
 ```
-*Requires:* The type `BidirectionalIterator` shall satisfy the
-requirements of a Bidirectional Iterator ([[bidirectional.iterators]]).
 *Effects:* Determines whether there is a match between the regular
 expression `e`, and all of the character sequence \[`first`, `last`).
 The parameter `flags` is used to control how the expression is matched
 against the character sequence. When determining if there is a match,
@@ -2180,16 +1712,16 @@ regex_search("GetValues", m, re);   // returns true, and m[0] contains "Get"
 regex_match ("GetValues", m, re);       // returns false
 ```
 — *end example*]
-*Postconditions:* `m.ready() == true` in all cases. If the function
-returns `false`, then the effect on parameter `m` is unspecified except
-that `m.size()` returns `0` and `m.empty()` returns `true`. Otherwise
-the effects on parameter `m` are given in Table  [[tab:re:alg:match]].
-**Table: Effects of `regex_match` algorithm** <a id="tab:re:alg:match">[tab:re:alg:match]</a>
 | Element              | Value                                                                                                                                                                               |
 | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `m.size()`           | `1 + e.mark_count()`                                                                                                                                                                |
 | `m.empty()`          | `false`                                                                                                                                                                             |
@@ -2266,25 +1798,25 @@ template <class BidirectionalIterator, class Allocator, class charT, class trait
                     match_results<BidirectionalIterator, Allocator>& m,
                     const basic_regex<charT, traits>& e,
                     regex_constants::match_flag_type flags = regex_constants::match_default);
 ```
-*Requires:* Type `BidirectionalIterator` shall satisfy the requirements
-of a Bidirectional Iterator ([[bidirectional.iterators]]).
 *Effects:* Determines whether there is some sub-sequence within
 \[`first`, `last`) that matches the regular expression `e`. The
 parameter `flags` is used to control how the expression is matched
 against the character sequence. Returns `true` if such a sequence
 exists, `false` otherwise.
-*Postconditions:* `m.ready() == true` in all cases. If the function
-returns `false`, then the effect on parameter `m` is unspecified except
-that `m.size()` returns `0` and `m.empty()` returns `true`. Otherwise
-the effects on parameter `m` are given in Table  [[tab:re:alg:search]].
-**Table: Effects of `regex_search` algorithm** <a id="tab:re:alg:search">[tab:re:alg:search]</a>
 | Element              | Value                                                                                                                                                                               |
 | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `m.size()`           | `1 + e.mark_count()`                                                                                                                                                                |
 | `m.empty()`          | `false`                                                                                                                                                                             |
@@ -2513,11 +2045,10 @@ namespace std {
                      const regex_type&&,
                      regex_constants::match_flag_type = regex_constants::match_default) = delete;
       regex_iterator(const regex_iterator&);
       regex_iterator& operator=(const regex_iterator&);
       bool operator==(const regex_iterator&) const;
-      bool operator!=(const regex_iterator&) const;
       const value_type& operator*() const;
       const value_type* operator->() const;
       regex_iterator& operator++();
       regex_iterator operator++(int);
@@ -2537,11 +2068,11 @@ iterator holds a *zero-length match* if `match[0].matched == true` and
 [*Note 1*: For example, this can occur when the part of the regular
 expression that matched consists only of an assertion (such as `'^'`,
 `'$'`, `'\b'`, `'\B'`). — *end note*]
-#### `regex_iterator` constructors <a id="re.regiter.cnstr">[[re.regiter.cnstr]]</a>
 ``` cpp
 regex_iterator();
 ```
@@ -2552,15 +2083,15 @@ regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
                const regex_type& re,
                regex_constants::match_flag_type m = regex_constants::match_default);
 ```
 *Effects:* Initializes `begin` and `end` to `a` and `b`, respectively,
-sets `pregex` to `&re`, sets `flags` to `m`, then calls
 `regex_search(begin, end, match, *pregex, flags)`. If this call returns
 `false` the constructor sets `*this` to the end-of-sequence iterator.
-#### `regex_iterator` comparisons <a id="re.regiter.comp">[[re.regiter.comp]]</a>
 ``` cpp
 bool operator==(const regex_iterator& right) const;
 ```
@@ -2573,17 +2104,11 @@ iterators or if the following conditions all hold:
 - `flags == right.flags`, and
 - `match[0] == right.match[0]`;
 otherwise `false`.
-``` cpp
-bool operator!=(const regex_iterator& right) const;
-```
-*Returns:* `!(*this == right)`.
-#### `regex_iterator` indirection <a id="re.regiter.deref">[[re.regiter.deref]]</a>
 ``` cpp
 const value_type& operator*() const;
 ```
@@ -2591,13 +2116,13 @@ const value_type& operator*() const;
 ``` cpp
 const value_type* operator->() const;
 ```
-*Returns:* `&match`.
-#### `regex_iterator` increment <a id="re.regiter.incr">[[re.regiter.incr]]</a>
 ``` cpp
 regex_iterator& operator++();
 ```
@@ -2639,11 +2164,11 @@ offset from the sequence passed in the call to
 `regex_search`. — *end note*]
 It is unspecified how the implementation makes these adjustments.
 [*Note 2*: This means that a compiler may call an
-implementation-specific search function, in which case a user-defined
 specialization of `regex_search` will not be called. — *end note*]
 ``` cpp
 regex_iterator operator++(int);
 ```
@@ -2759,11 +2284,10 @@ namespace std {
                            regex_constants::match_flag_type m =
                              regex_constants::match_default) = delete;
       regex_token_iterator(const regex_token_iterator&);
       regex_token_iterator& operator=(const regex_token_iterator&);
       bool operator==(const regex_token_iterator&) const;
-      bool operator!=(const regex_token_iterator&) const;
       const value_type& operator*() const;
       const value_type* operator->() const;
       regex_token_iterator& operator++();
       regex_token_iterator operator++(int);
@@ -2786,16 +2310,16 @@ suffix iterator the member `result` holds a pointer to the data member
 `suffix.first` points to the beginning of the final sequence, and
 `suffix.second` points to the end of the final sequence.
 [*Note 1*: For a suffix iterator, data member `suffix.first` is the
 same as the end of the last match found, and `suffix.second` is the same
-as the end of the target sequence — *end note*]
 The *current match* is `(*position).prefix()` if `subs[N] == -1`, or
 `(*position)[subs[N]]` for any other value of `subs[N]`.
-#### `regex_token_iterator` constructors <a id="re.tokiter.cnstr">[[re.tokiter.cnstr]]</a>
 ``` cpp
 regex_token_iterator();
 ```
@@ -2822,30 +2346,28 @@ template <size_t N>
                        const regex_type& re,
                        const int (&submatches)[N],
                        regex_constants::match_flag_type m = regex_constants::match_default);
 ```
-*Requires:* Each of the initialization values of `submatches` shall be
 `>= -1`.
 *Effects:* The first constructor initializes the member `subs` to hold
-the single value `submatch`. The second constructor initializes the
-member `subs` to hold a copy of the argument `submatches`. The third and
-fourth constructors initialize the member `subs` to hold a copy of the
-sequence of integer values pointed to by the iterator range
-\[`submatches.begin()`, `submatches.end()`) and \[`&submatches`,
-`&submatches + N`), respectively.
 Each constructor then sets `N` to 0, and `position` to
 `position_iterator(a, b, re, m)`. If `position` is not an
 end-of-sequence iterator the constructor sets `result` to the address of
 the current match. Otherwise if any of the values stored in `subs` is
 equal to -1 the constructor sets `*this` to a suffix iterator that
 points to the range \[`a`, `b`), otherwise the constructor sets `*this`
 to an end-of-sequence iterator.
-#### `regex_token_iterator` comparisons <a id="re.tokiter.comp">[[re.tokiter.comp]]</a>
 ``` cpp
 bool operator==(const regex_token_iterator& right) const;
 ```
@@ -2854,17 +2376,11 @@ iterators, or if `*this` and `right` are both suffix iterators and
 `suffix == right.suffix`; otherwise returns `false` if `*this` or
 `right` is an end-of-sequence iterator or a suffix iterator. Otherwise
 returns `true` if `position == right.position`, `N == right.N`, and
 `subs == right.subs`. Otherwise returns `false`.
-``` cpp
-bool operator!=(const regex_token_iterator& right) const;
-```
-*Returns:* `!(*this == right)`.
-#### `regex_token_iterator` indirection <a id="re.tokiter.deref">[[re.tokiter.deref]]</a>
 ``` cpp
 const value_type& operator*() const;
 ```
@@ -2874,11 +2390,11 @@ const value_type& operator*() const;
 const value_type* operator->() const;
 ```
 *Returns:* `result`.
-#### `regex_token_iterator` increment <a id="re.tokiter.incr">[[re.tokiter.incr]]</a>
 ``` cpp
 regex_token_iterator& operator++();
 ```
@@ -2927,58 +2443,57 @@ including the formatted string input functions. Instead they shall call
 the appropriate traits member function to achieve the required effect.
 The following productions within the ECMAScript grammar are modified as
 follows:
-``` cpp
 ClassAtom::
-  -
   ClassAtomNoDash
   ClassAtomExClass
   ClassAtomCollatingElement
   ClassAtomEquivalence
 IdentityEscape::
-  SourceCharacter but not c
 ```
 The following new productions are then added:
-``` cpp
 ClassAtomExClass::
-  [: ClassName :]
 ClassAtomCollatingElement::
-  [. ClassName .]
 ClassAtomEquivalence::
-  [= ClassName =]
 ClassName::
   ClassNameCharacter
   ClassNameCharacter ClassName
 ClassNameCharacter::
-  SourceCharacter but not one of "." "=" ":"
 ```
-The productions `ClassAtomExClass`, `ClassAtomCollatingElement` and
-`ClassAtomEquivalence` provide functionality equivalent to that of the
 same features in regular expressions in POSIX.
 The regular expression grammar may be modified by any
 `regex_constants::syntax_option_type` flags specified when constructing
 an object of type specialization of `basic_regex` according to the rules
-in Table [[tab:re:syntaxoption]].
-A `ClassName` production, when used in `ClassAtomExClass`, is not valid
-if `traits_inst.lookup_classname` returns zero for that name. The names
-recognized as valid `ClassName`s are determined by the type of the
-traits class, but at least the following names shall be recognized:
-`alnum`, `alpha`, `blank`, `cntrl`, `digit`, `graph`, `lower`, `print`,
-`punct`, `space`, `upper`, `xdigit`, `d`, `s`, `w`. In addition the
-following expressions shall be equivalent:
 ``` cpp
 \d and [[:digit:]]
 \D and [^[:digit:]]
@@ -2990,22 +2505,22 @@ following expressions shall be equivalent:
 \w and [_[:alnum:]]
 \W and [^_[:alnum:]]
 ```
-A `ClassName` production when used in a `ClassAtomCollatingElement`
-production is not valid if the value returned by
-`traits_inst.lookup_collatename` for that name is an empty string.
 The results from multiple calls to `traits_inst.lookup_classname` can be
-bitwise OR’ed together and subsequently passed to `traits_inst.isctype`.
-A `ClassName` production when used in a `ClassAtomEquivalence`
-production is not valid if the value returned by
-`traits_inst.lookup_collatename` for that name is an empty string or if
-the value returned by `traits_inst.transform_primary` for the result of
-the call to `traits_inst.lookup_collatename` is an empty string.
 When the sequence of characters being transformed to a finite state
 machine contains an invalid class name the translator shall throw an
 exception object of type `regex_error`.
@@ -3020,13 +2535,13 @@ Where the regular expression grammar requires the conversion of a
 sequence of characters to an integral value, this is accomplished by
 calling `traits_inst.value`.
 The behavior of the internal finite state machine representation when
 used to match a sequence of characters is as described in ECMA-262. The
-behavior is modified according to any match_flag_type flags (
-[[re.matchflag]]) specified when using the regular expression object in
-one of the regular expression algorithms ([[re.alg]]). The behavior is
 also localized by interaction with the traits class template parameter
 as follows:
 - During matching of a regular expression finite state machine against a
   sequence of characters, two characters `c` and `d` are compared using
@@ -3039,24 +2554,24 @@ as follows:
     `traits_inst.translate(c) == traits_inst.translate(d)`;
   - otherwise, the two characters are equal if `c == d`.
 - During matching of a regular expression finite state machine against a
   sequence of characters, comparison of a collating element range
   `c1-c2` against a character `c` is conducted as follows: if
-  `flags() & regex_constants::collate` is false then the character `c`
   is matched if `c1
   <= c && c <= c2`, otherwise `c` is matched in accordance with the
   following algorithm:
   ``` cpp
   string_type str1 = string_type(1,
     flags() & icase ?
-      traits_inst.translate_nocase(c1) : traits_inst.translate(c1);
   string_type str2 = string_type(1,
     flags() & icase ?
-      traits_inst.translate_nocase(c2) : traits_inst.translate(c2);
   string_type str = string_type(1,
     flags() & icase ?
-      traits_inst.translate_nocase(c) : traits_inst.translate(c);
   return traits_inst.transform(str1.begin(), str1.end())
         <= traits_inst.transform(str.begin(), str.end())
     && traits_inst.transform(str.begin(), str.end())
         <= traits_inst.transform(str2.begin(), str2.end());
   ```
@@ -3070,10 +2585,12 @@ as follows:
   sequence of characters, a character `c` is a member of a character
   class designated by an iterator range \[`first`, `last`) if
   `traits_inst.isctype(c, traits_inst.lookup_classname(first, last, flags() & icase))`
   is `true`.
 <!-- Link reference definitions -->
 [algorithms]: algorithms.md#algorithms
 [bidirectional.iterators]: iterators.md#bidirectional.iterators
 [bitmask.types]: library.md#bitmask.types
 [container.requirements.general]: containers.md#container.requirements.general
@@ -3095,14 +2612,12 @@ as follows:
 [re.grammar]: #re.grammar
 [re.iter]: #re.iter
 [re.matchflag]: #re.matchflag
 [re.regex]: #re.regex
 [re.regex.assign]: #re.regex.assign
-[re.regex.const]: #re.regex.const
 [re.regex.construct]: #re.regex.construct
 [re.regex.locale]: #re.regex.locale
-[re.regex.nmswap]: #re.regex.nmswap
 [re.regex.nonmemb]: #re.regex.nonmemb
 [re.regex.operations]: #re.regex.operations
 [re.regex.swap]: #re.regex.swap
 [re.regiter]: #re.regiter
 [re.regiter.cnstr]: #re.regiter.cnstr
@@ -3120,27 +2635,20 @@ as follows:
 [re.results.state]: #re.results.state
 [re.results.swap]: #re.results.swap
 [re.submatch]: #re.submatch
 [re.submatch.members]: #re.submatch.members
 [re.submatch.op]: #re.submatch.op
 [re.syn]: #re.syn
 [re.synopt]: #re.synopt
 [re.tokiter]: #re.tokiter
 [re.tokiter.cnstr]: #re.tokiter.cnstr
 [re.tokiter.comp]: #re.tokiter.comp
 [re.tokiter.deref]: #re.tokiter.deref
 [re.tokiter.incr]: #re.tokiter.incr
 [re.traits]: #re.traits
 [sequence.reqmts]: containers.md#sequence.reqmts
 [strings.general]: strings.md#strings.general
-[tab:re.lib.summary]: #tab:re.lib.summary
-[tab:re.traits.classnames]: #tab:re.traits.classnames
-[tab:re:RegexpTraits]: #tab:re:RegexpTraits
-[tab:re:alg:match]: #tab:re:alg:match
-[tab:re:alg:search]: #tab:re:alg:search
-[tab:re:errortype]: #tab:re:errortype
-[tab:re:matchflag]: #tab:re:matchflag
-[tab:re:results:assign]: #tab:re:results:assign
-[tab:re:syntaxoption]: #tab:re:syntaxoption
 [^1]: For example, if the parameter `icase` is `true` then `[[:lower:]]`
     is the same as `[[:alpha:]]`.

 This Clause describes components that C++ programs may use to perform
 operations involving regular expression matching and searching.
 The following subclauses describe a basic regular expression class
+template and its traits that can handle char-like [[strings.general]]
 template arguments, two specializations of this class template that
 handle sequences of `char` and `wchar_t`, a class template that holds
 the result of a regular expression match, a series of algorithms that
 allow a character sequence to be operated upon by a regular expression,
 and two iterator types for enumerating regular expression matches, as
+summarized in [[re.summary]].
+**Table: Regular expressions library summary** <a id="re.summary">[re.summary]</a>
 | Subclause       |                             | Header    |
 | --------------- | --------------------------- | --------- |
 | [[re.def]]      | Definitions                 |           |
 | [[re.req]]      | Requirements                |           |
+| [[re.const]]    | Constants                   | `<regex>` |
 | [[re.badexp]]   | Exception type              |           |
 | [[re.traits]]   | Traits                      |           |
+| [[re.regex]]    | Regular expression template | |
 | [[re.submatch]] | Submatches                  |           |
 | [[re.results]]  | Match results               |           |
 | [[re.alg]]      | Algorithms                  |           |
 | [[re.iter]]     | Iterators                   |           |
 | [[re.grammar]]  | Grammar                     |           |
 ## Requirements <a id="re.req">[[re.req]]</a>
 This subclause defines requirements on classes representing regular
 expression traits.
+[*Note 1*: The class template `regex_traits`, defined in [[re.traits]],
+meets these requirements. — *end note*]
+The class template `basic_regex`, defined in [[re.regex]], needs a set
+of related types and functions to complete the definition of its
 semantics. These types and functions are provided as a set of member
 *typedef-name*s and functions in the template parameter `traits` used by
 the `basic_regex` class template. This subclause defines the semantics
 of these members.
 To specialize class template `basic_regex` for a character container
 `CharT` and its related regular expression traits class `Traits`, use
 `basic_regex<CharT, Traits>`.
+In [[re.req]] `X` denotes a traits class defining types and functions
+for the character container type `charT`; `u` is an object of type `X`;
+`v` is an object of type `const
 X`; `p` is a value of type `const charT*`; `I1` and `I2` are input
+iterators [[input.iterators]]; `F1` and `F2` are forward iterators
+[[forward.iterators]]; `c` is a value of type `const charT`; `s` is an
 object of type `X::string_type`; `cs` is an object of type
 `const X::string_type`; `b` is a value of type `bool`; `I` is a value of
 type `int`; `cl` is an object of type `X::char_class_type`, and `loc` is
 an object of type `X::locale_type`.
 [*Note 2*: The value of *I* will only be 8, 10, or 16. — *end note*]
+[*Note 3*: Class template `regex_traits` meets the requirements for a
+regular expression traits class when it is specialized for `char` or
 `wchar_t`. This class template is described in the header `<regex>`, and
+is described in [[re.traits]]. — *end note*]
 ## Header `<regex>` synopsis <a id="re.syn">[[re.syn]]</a>
 ``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   // [re.const], regex constants
   namespace regex_constants {
     using syntax_option_type = T1;
   // [re.submatch.op], sub_match non-member operators
   template<class BiIter>
     bool operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
   template<class BiIter>
+ auto operator<=>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
   template<class BiIter, class ST, class SA>
     bool operator==(
       const sub_match<BiIter>& lhs,
       const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
   template<class BiIter, class ST, class SA>
+ auto operator<=>(
       const sub_match<BiIter>& lhs,
       const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
   template<class BiIter>
     bool operator==(const sub_match<BiIter>& lhs,
                     const typename iterator_traits<BiIter>::value_type* rhs);
   template<class BiIter>
+ auto operator<=>(const sub_match<BiIter>& lhs,
                      const typename iterator_traits<BiIter>::value_type* rhs);
   template<class BiIter>
     bool operator==(const sub_match<BiIter>& lhs,
                     const typename iterator_traits<BiIter>::value_type& rhs);
   template<class BiIter>
+ auto operator<=>(const sub_match<BiIter>& lhs,
                      const typename iterator_traits<BiIter>::value_type& rhs);
   template<class charT, class ST, class BiIter>
     basic_ostream<charT, ST>&
       operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
   // match_results comparisons
   template<class BidirectionalIterator, class Allocator>
     bool operator==(const match_results<BidirectionalIterator, Allocator>& m1,
                     const match_results<BidirectionalIterator, Allocator>& m2);
   // [re.results.swap], match_results swap
   template<class BidirectionalIterator, class Allocator>
     void swap(match_results<BidirectionalIterator, Allocator>& m1,
               match_results<BidirectionalIterator, Allocator>& m2);
   inline constexpr syntax_option_type multiline = unspecified;
 }
 ```
 The type `syntax_option_type` is an *implementation-defined* bitmask
+type [[bitmask.types]]. Setting its elements has the effects listed in
+[[re.synopt]]. A valid value of type `syntax_option_type` shall have at
+most one of the grammar elements `ECMAScript`, `basic`, `extended`,
+`awk`, `grep`, `egrep`, set. If no grammar element is set, the default
+grammar is `ECMAScript`.
+**Table: `syntax_option_type` effects** <a id="re.synopt">[re.synopt]</a>
 | Element        | Effect(s) if set                                                                                                                                                                                                                                                                                                             |
+| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| % `icase`      | Specifies that matching of regular expressions against a character container sequence shall be performed without regard to case. \indexlibrarymember{syntax_option_type}{icase}%                                                                                                                                             |
+| % `nosubs`     | Specifies that no sub-expressions shall be considered to be marked, so that when a regular expression is matched against a character container sequence, no sub-expression matches shall be stored in the supplied `match_results` object. \indexlibrarymember{syntax_option_type}{nosubs}% |
+| % `optimize`   | Specifies that the regular expression engine should pay more attention to the speed with which regular expressions are matched, and less to the speed with which regular expression objects are constructed. Otherwise it has no detectable effect on the program output. \indexlibrarymember{syntax_option_type}{optimize}% |
+| % `collate`    | Specifies that character ranges of the form `"[a-b]"` shall be locale sensitive. \indexlibrarymember{syntax_option_type}{collate}% \indextext{locale}%                                                                                                                                                                       |
+| % `ECMAScript` | Specifies that the grammar recognized by the regular expression engine shall be that used by ECMAScript in ECMA-262, as modified in~ [[re.grammar]]. \xref ECMA-262 15.10 \indextext{ECMAScript}% \indexlibrarymember{syntax_option_type}{ECMAScript}% |
+| % `basic`      | Specifies that the grammar recognized by the regular expression engine shall be that used by basic regular expressions in POSIX. \xref POSIX, Base Definitions and Headers, Section 9.3 \indextext{POSIX!regular expressions}% \indexlibrarymember{syntax_option_type}{basic}% |
+| % `extended`   | Specifies that the grammar recognized by the regular expression engine shall be that used by extended regular expressions in POSIX. \xref POSIX, Base Definitions and Headers, Section 9.4 \indextext{POSIX!extended regular expressions}% \indexlibrarymember{syntax_option_type}{extended}% |
+| % `awk`        | Specifies that the grammar recognized by the regular expression engine shall be that used by the utility awk in POSIX. \indextext{\idxcode{awk}}% \indexlibrarymember{syntax_option_type}{awk}%                                                                                                                              |
+| % `grep`       | Specifies that the grammar recognized by the regular expression engine shall be that used by the utility grep in POSIX. \indextext{\idxcode{grep}}% \indexlibrarymember{syntax_option_type}{grep}%                                                                                                                           |
+| % `egrep`      | Specifies that the grammar recognized by the regular expression engine shall be that used by the utility grep when given the -E option in POSIX. \indextext{\idxcode{egrep}}% \indexlibrarymember{syntax_option_type}{egrep}%                                                                                                |
+| % `multiline`  | Specifies that `^` shall match the beginning of a line and `$` shall match the end of a line, if the `ECMAScript` engine is selected. \indextext{\idxcode{multiline}}% \indexlibrarymember{syntax_option_type}{multiline}% |
 ### Bitmask type `match_flag_type` <a id="re.matchflag">[[re.matchflag]]</a>
 ``` cpp
   inline constexpr match_flag_type format_no_copy = unspecified;
   inline constexpr match_flag_type format_first_only = unspecified;
 }
 ```
+The type `match_flag_type` is an *implementation-defined* bitmask type
+[[bitmask.types]]. The constants of that type, except for
 `match_default` and `format_default`, are bitmask elements. The
 `match_default` and `format_default` constants are empty bitmasks.
 Matching a regular expression against a sequence of characters
 \[`first`, `last`) proceeds according to the rules of the grammar
 specified for the regular expression object, modified according to the
+effects listed in [[re.matchflag]] for any bitmask elements set.
 **Table: `regex_constants::match_flag_type` effects when obtaining a match against a
+     character container sequence {[}`first`, `last`{)}.** <a id="re.matchflag">[re.matchflag]</a>
 | Element                                                       | Effect(s) if set                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| ------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| % \indexlibraryglobal{match_not_bol}% `match_not_bol`         | The first character in the sequence {[}`first`, `last`{)} shall be treated as though it is not at the beginning of a line, so the character \verb|^| in the regular expression shall not match {[}`first`, `first`{)}.                                                                                                                                                                                                                                                      |
+| % \indexlibraryglobal{match_not_eol}% `match_not_eol`         | The last character in the sequence {[}`first`, `last`{)} shall be treated as though it is not at the end of a line, so the character \verb|"$"| in the regular expression shall not match {[}`last`, `last`{)}.                                                                                                                                                                                                                                                             |
+| % \indexlibraryglobal{match_not_bow}% `match_not_bow`         | The expression \verb|"b"| shall not match the sub-sequence {[}`first`, `first`{)}.                                                                                                                                                                                                                                                                                                                                                                                          |
+| % \indexlibraryglobal{match_not_eow}% `match_not_eow`         | The expression \verb|"b"| shall not match the sub-sequence {[}`last`, `last`{)}.                                                                                                                                                                                                                                                                                                                                                                                            |
+| % \indexlibraryglobal{match_any}% `match_any`                 | If more than one match is possible then any match is an acceptable result.                                                                                                                                                                                                                                                                                                                                                                                                  |
+| % \indexlibraryglobal{match_not_null}% `match_not_null`       | The expression shall not match an empty sequence.                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| % \indexlibraryglobal{match_continuous}% `match_continuous`   | The expression shall only match a sub-sequence that begins at `first`.                                                                                                                                                                                                                                                                                                                                                                                                      |
+| % \indexlibraryglobal{match_prev_avail}% `match_prev_avail`   | \verb!--first! is a valid iterator position. When this flag is set the flags `match_not_bol` and `match_not_bow` shall be ignored by the regular expression algorithms [[re.alg]] and iterators [[re.iter]]. |
+| % \indexlibraryglobal{format_default}% `format_default`       | When a regular expression match is to be replaced by a new string, the new string shall be constructed using the rules used by the ECMAScript replace function in ECMA-262, part 15.5.4.11 String.prototype.replace. In addition, during search and replace operations all non-overlapping occurrences of the regular expression shall be located and replaced, and sections of the input that did not match the expression shall be copied unchanged to the output string. |
+| % \indexlibraryglobal{format_sed}% `format_sed`               | When a regular expression match is to be replaced by a new string, the new string shall be constructed using the rules used by the sed utility in POSIX.                                                                                                                                                                                                                                                                                                                    |
+| % \indexlibraryglobal{format_no_copy}% `format_no_copy`       | During a search and replace operation, sections of the character container sequence being searched that do not match the regular expression shall not be copied to the output string.                                                                                                                                                                                                                                                                                       |
+| % \indexlibraryglobal{format_first_only}% `format_first_only` | When specified during a search and replace operation, only the first occurrence of the regular expression shall be replaced.                                                                                                                                                                                                                                                                                                                                                |
 ### Implementation-defined `error_type` <a id="re.err">[[re.err]]</a>
 ``` cpp
   inline constexpr error_type error_complexity = unspecified;
   inline constexpr error_type error_stack = unspecified;
 }
 ```
+The type `error_type` is an *implementation-defined* enumerated type
+[[enumerated.types]]. Values of type `error_type` represent the error
+conditions described in [[re.err]]:
+**Table: `error_type` values in the C locale** <a id="re.err">[re.err]</a>
 | Value                | Error condition                                                                                                         |
 | -------------------- | ----------------------------------------------------------------------------------------------------------------------- |
 | `error_collate`      | The expression contained an invalid collating element name.                                                             |
 | % `error_ctype`      | The expression contained an invalid character class name.                                                               |
 ``` cpp
 regex_error(regex_constants::error_type ecode);
 ```
+*Ensures:* `ecode == code()`.
 ``` cpp
 regex_constants::error_type code() const;
 ```
   template<class charT>
     struct regex_traits {
       using char_type       = charT;
       using string_type     = basic_string<char_type>;
       using locale_type     = locale;
+      using char_class_type = bitmask_type;
       regex_traits();
       static size_t length(const char_type* p);
       charT translate(charT c) const;
       charT translate_nocase(charT c) const;
     };
 }
 ```
 The specializations `regex_traits<char>` and `regex_traits<wchar_t>`
+meet the requirements for a regular expression traits class [[re.req]].
 ``` cpp
 using char_class_type = bitmask_type;
 ```
 *Effects:* As if by:
 ``` cpp
 string_type str(first, last);
 return use_facet<collate<charT>>(
+  getloc()).transform(str.data(), str.data() + str.length());
 ```
 ``` cpp
 template<class ForwardIterator>
   string_type transform_primary(ForwardIterator first, ForwardIterator last) const;
 ``` cpp
 template<class ForwardIterator>
   string_type lookup_collatename(ForwardIterator first, ForwardIterator last) const;
 ```
+*Returns:* A sequence of one or more characters that represents the
 collating element consisting of the character sequence designated by the
 iterator range \[`first`, `last`). Returns an empty string if the
 character sequence is not a valid collating element.
 ``` cpp
 template<class ForwardIterator>
   char_class_type lookup_classname(
     ForwardIterator first, ForwardIterator last, bool icase = false) const;
 ```
+*Returns:* An unspecified value that represents the character
 classification named by the character sequence designated by the
 iterator range \[`first`, `last`). If the parameter `icase` is `true`
 then the returned mask identifies the character classification without
 regard to the case of the characters being matched, otherwise it does
 honor the case of the characters being matched.[^1] The value returned
 shall be independent of the case of the characters in the character
 sequence. If the name is not recognized then returns
 `char_class_type()`.
 *Remarks:* For `regex_traits<char>`, at least the narrow character names
+in [[re.traits.classnames]] shall be recognized. For
 `regex_traits<wchar_t>`, at least the wide character names in
+[[re.traits.classnames]] shall be recognized.
 ``` cpp
 bool isctype(charT c, char_class_type f) const;
 ```
 template<class C>
   ctype_base::mask convert(typename regex_traits<C>::char_class_type f);
 ```
 that returns a value in which each `ctype_base::mask` value
+corresponding to a value in `f` named in [[re.traits.classnames]] is
+set, then the result is determined as if by:
 ``` cpp
 ctype_base::mask m = convert<charT>(f);
 const ctype<charT>& ct = use_facet<ctype<charT>>(getloc());
 if (ct.is(m, c)) {
 ``` cpp
 int value(charT ch, int radix) const;
 ```
+*Preconditions:* The value of `radix` is 8, 10, or 16.
+*Returns:* The value represented by the digit `ch` in base `radix` if
 the character `ch` is a valid digit in base `radix`; otherwise returns
 `-1`.
 ``` cpp
 locale_type imbue(locale_type loc);
 [*Note 1*: Calling `imbue` with a different locale than the one
 currently in use invalidates all cached data held by
 `*this`. — *end note*]
+*Returns:* If no locale has been previously imbued then a copy of the
 global locale in effect at the time of construction of `*this`,
 otherwise a copy of the last argument passed to `imbue`.
+*Ensures:* `getloc() == loc`.
 ``` cpp
 locale_type getloc() const;
 ```
+*Returns:* If no locale has been imbued then a copy of the global locale
 in effect at the time of construction of `*this`, otherwise a copy of
 the last argument passed to `imbue`.
+**Table: Character class names and corresponding `ctype` masks** <a id="re.traits.classnames">[re.traits.classnames]</a>
 | Narrow character name | Wide character name | Corresponding `ctype_base::mask` value |
 | --------------------- | ------------------- | -------------------------------------- |
 | `"alnum"`             | `L"alnum"`          | `ctype_base::alnum`                    |
 | `"alpha"`             | `L"alpha"`          | `ctype_base::alpha`                    |
 representation. It is not specified what form this representation takes,
 nor how it is accessed by algorithms that operate on regular
 expressions.
 [*Note 1*: Implementations will typically declare some function
+templates as friends of `basic_regex` to achieve this. — *end note*]
 The functions described in this Clause report errors by throwing
 exceptions of type `regex_error`.
 ``` cpp
 namespace std {
   template<class charT, class traits = regex_traits<charT>>
     class basic_regex {
     public:
+      // types
       using value_type  =          charT;
       using traits_type =          traits;
       using string_type = typename traits::string_type;
       using flag_type   =          regex_constants::syntax_option_type;
       using locale_type = typename traits::locale_type;
+      // [re.synopt], constants
+      static constexpr flag_type icase = regex_constants::icase;
+      static constexpr flag_type nosubs = regex_constants::nosubs;
+      static constexpr flag_type optimize = regex_constants::optimize;
+      static constexpr flag_type collate = regex_constants::collate;
+      static constexpr flag_type ECMAScript = regex_constants::ECMAScript;
+      static constexpr flag_type basic = regex_constants::basic;
+      static constexpr flag_type extended = regex_constants::extended;
+      static constexpr flag_type awk = regex_constants::awk;
+      static constexpr flag_type grep = regex_constants::grep;
+      static constexpr flag_type egrep = regex_constants::egrep;
+      static constexpr flag_type multiline = regex_constants::multiline;
       // [re.regex.construct], construct/copy/destroy
       basic_regex();
       explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript);
       basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript);
       basic_regex(const basic_regex&);
       basic_regex(basic_regex&&) noexcept;
       template<class ST, class SA>
+        explicit basic_regex(const basic_string<charT, ST, SA>& s,
                              flag_type f = regex_constants::ECMAScript);
       template<class ForwardIterator>
         basic_regex(ForwardIterator first, ForwardIterator last,
                     flag_type f = regex_constants::ECMAScript);
+      basic_regex(initializer_list<charT> il, flag_type f = regex_constants::ECMAScript);
       ~basic_regex();
       // [re.regex.assign], assign
+      basic_regex& operator=(const basic_regex& e);
+      basic_regex& operator=(basic_regex&& e) noexcept;
+      basic_regex& operator=(const charT* p);
+      basic_regex& operator=(initializer_list<charT> il);
+      template<class ST, class SA>
+        basic_regex& operator=(const basic_string<charT, ST, SA>& s);
+      basic_regex& assign(const basic_regex& e);
+      basic_regex& assign(basic_regex&& e) noexcept;
+      basic_regex& assign(const charT* p, flag_type f = regex_constants::ECMAScript);
+      basic_regex& assign(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript);
+      template<class ST, class SA>
+        basic_regex& assign(const basic_string<charT, ST, SA>& s,
                             flag_type f = regex_constants::ECMAScript);
       template<class InputIterator>
         basic_regex& assign(InputIterator first, InputIterator last,
                             flag_type f = regex_constants::ECMAScript);
       basic_regex& assign(initializer_list<charT>,
+                          flag_type f = regex_constants::ECMAScript);
       // [re.regex.operations], const operations
       unsigned mark_count() const;
       flag_type flags() const;
                 regex_constants::syntax_option_type = regex_constants::ECMAScript)
       -> basic_regex<typename iterator_traits<ForwardIterator>::value_type>;
 }
 ```
+### Constructors <a id="re.regex.construct">[[re.regex.construct]]</a>
 ``` cpp
 basic_regex();
 ```
+*Ensures:* `*this` does not match any character sequence.
 ``` cpp
 explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript);
 ```
+*Preconditions:* \[`p`, `p + char_traits<charT>::length(p)`) is a valid
+range.
+*Effects:* The object’s internal finite state machine is constructed
+from the regular expression contained in the sequence of characters
+\[`p`, `p + char_traits<charT>::length(p)`), and interpreted according
+to the flags `f`.
+*Ensures:* `flags()` returns `f`. `mark_count()` returns the number of
+marked sub-expressions within the expression.
+*Throws:* `regex_error` if \[`p`, `p + char_traits<charT>::length(p)`)
+is not a valid regular expression.
 ``` cpp
+basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript);
 ```
+*Preconditions:* \[`p`, `p + len`) is a valid range.
+*Effects:* The object’s internal finite state machine is constructed
+from the regular expression contained in the sequence of characters
+\[`p`, `p + len`), and interpreted according the flags specified in `f`.
+*Ensures:* `flags()` returns `f`. `mark_count()` returns the number of
+marked sub-expressions within the expression.
+*Throws:* `regex_error` if \[`p`, `p + len`) is not a valid regular
+expression.
 ``` cpp
 basic_regex(const basic_regex& e);
 ```
+*Ensures:* `flags()` and `mark_count()` return `e.flags()` and
 `e.mark_count()`, respectively.
 ``` cpp
 basic_regex(basic_regex&& e) noexcept;
 ```
+*Ensures:* `flags()` and `mark_count()` return the values that
 `e.flags()` and `e.mark_count()`, respectively, had before construction.
 ``` cpp
 template<class ST, class SA>
   explicit basic_regex(const basic_string<charT, ST, SA>& s,
                        flag_type f = regex_constants::ECMAScript);
 ```
+*Effects:* The object’s internal finite state machine is constructed
+from the regular expression contained in the string `s`, and interpreted
+according to the flags specified in `f`.
+*Ensures:* `flags()` returns `f`. `mark_count()` returns the number of
+marked sub-expressions within the expression.
 *Throws:* `regex_error` if `s` is not a valid regular expression.
 ``` cpp
 template<class ForwardIterator>
   basic_regex(ForwardIterator first, ForwardIterator last,
               flag_type f = regex_constants::ECMAScript);
 ```
+*Effects:* The object’s internal finite state machine is constructed
+from the regular expression contained in the sequence of characters
+\[`first`, `last`), and interpreted according to the flags specified in
+`f`.
+*Ensures:* `flags()` returns `f`. `mark_count()` returns the number of
+marked sub-expressions within the expression.
 *Throws:* `regex_error` if the sequence \[`first`, `last`) is not a
 valid regular expression.
 ``` cpp
 basic_regex(initializer_list<charT> il, flag_type f = regex_constants::ECMAScript);
 ```
 *Effects:* Same as `basic_regex(il.begin(), il.end(), f)`.
+### Assignment <a id="re.regex.assign">[[re.regex.assign]]</a>
 ``` cpp
 basic_regex& operator=(const basic_regex& e);
 ```
+*Ensures:* `flags()` and `mark_count()` return `e.flags()` and
 `e.mark_count()`, respectively.
 ``` cpp
 basic_regex& operator=(basic_regex&& e) noexcept;
 ```
+*Ensures:* `flags()` and `mark_count()` return the values that
 `e.flags()` and `e.mark_count()`, respectively, had before assignment.
 `e` is in a valid state with unspecified value.
 ``` cpp
+basic_regex& operator=(const charT* p);
 ```
+*Effects:* Equivalent to: `return assign(p);`
 ``` cpp
 basic_regex& operator=(initializer_list<charT> il);
 ```
+*Effects:* Equivalent to: `return assign(il.begin(), il.end());`
 ``` cpp
 template<class ST, class SA>
+  basic_regex& operator=(const basic_string<charT, ST, SA>& s);
 ```
+*Effects:* Equivalent to: `return assign(s);`
 ``` cpp
+basic_regex& assign(const basic_regex& e);
 ```
+*Effects:* Equivalent to: `return *this = e;`
 ``` cpp
+basic_regex& assign(basic_regex&& e) noexcept;
 ```
+*Effects:* Equivalent to: `return *this = std::move(e);`
 ``` cpp
+basic_regex& assign(const charT* p, flag_type f = regex_constants::ECMAScript);
 ```
+*Effects:* Equivalent to: `return assign(string_type(p), f);`
 ``` cpp
+basic_regex& assign(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript);
 ```
+*Effects:* Equivalent to: `return assign(string_type(p, len), f);`
 ``` cpp
+template<class ST, class SA>
+  basic_regex& assign(const basic_string<charT, ST, SA>& s,
                       flag_type f = regex_constants::ECMAScript);
 ```
 *Returns:* `*this`.
 *Effects:* Assigns the regular expression contained in the string `s`,
 interpreted according the flags specified in `f`. If an exception is
 thrown, `*this` is unchanged.
+*Ensures:* If no exception is thrown, `flags()` returns `f` and
 `mark_count()` returns the number of marked sub-expressions within the
 expression.
+*Throws:* `regex_error` if `s` is not a valid regular expression.
 ``` cpp
 template<class InputIterator>
   basic_regex& assign(InputIterator first, InputIterator last,
                       flag_type f = regex_constants::ECMAScript);
 ```
+*Effects:* Equivalent to: `return assign(string_type(first, last), f);`
 ``` cpp
 basic_regex& assign(initializer_list<charT> il,
                     flag_type f = regex_constants::ECMAScript);
 ```
+*Effects:* Equivalent to: `return assign(il.begin(), il.end(), f);`
+### Constant operations <a id="re.regex.operations">[[re.regex.operations]]</a>
 ``` cpp
 unsigned mark_count() const;
 ```
 ```
 *Effects:* Returns a copy of the regular expression syntax flags that
 were passed to the object’s constructor or to the last call to `assign`.
+### Locale <a id="re.regex.locale">[[re.regex.locale]]</a>
 ``` cpp
 locale_type imbue(locale_type loc);
 ```
 *Effects:* Returns the result of `traits_inst.getloc()` where
 `traits_inst` is a (default-initialized) instance of the template
 parameter `traits` stored within the object.
+### Swap <a id="re.regex.swap">[[re.regex.swap]]</a>
 ``` cpp
 void swap(basic_regex& e);
 ```
 *Effects:* Swaps the contents of the two regular expressions.
+*Ensures:* `*this` contains the regular expression that was in `e`, `e`
+contains the regular expression that was in `*this`.
 *Complexity:* Constant time.
+### Non-member functions <a id="re.regex.nonmemb">[[re.regex.nonmemb]]</a>
 ``` cpp
 template<class charT, class traits>
   void swap(basic_regex<charT, traits>& lhs, basic_regex<charT, traits>& rhs);
 ```
       int compare(const value_type* s) const;
     };
 }
 ```
+### Members <a id="re.submatch.members">[[re.submatch.members]]</a>
 ``` cpp
 constexpr sub_match();
 ```
 int compare(const value_type* s) const;
 ```
 *Returns:* `str().compare(s)`.
+### Non-member operators <a id="re.submatch.op">[[re.submatch.op]]</a>
+Let `SM-CAT(I)` be
+``` cpp
+compare_three_way_result_t<basic_string<typename iterator_traits<I>::value_type>>
+```
 ``` cpp
 template<class BiIter>
   bool operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 ```
 *Returns:* `lhs.compare(rhs) == 0`.
 ``` cpp
 template<class BiIter>
+ auto operator<=>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 ```
+*Returns:* `static_cast<`*`SM-CAT`*`(BiIter)>(lhs.compare(rhs) <=> 0)`.
 ``` cpp
 template<class BiIter, class ST, class SA>
   bool operator==(
       const sub_match<BiIter>& lhs,
 lhs.compare(typename sub_match<BiIter>::string_type(rhs.data(), rhs.size())) == 0
 ```
 ``` cpp
 template<class BiIter, class ST, class SA>
+ auto operator<=>(
       const sub_match<BiIter>& lhs,
       const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 ```
 *Returns:*
 ``` cpp
+static_cast<SM-CAT(BiIter)>(lhs.compare(
+    typename sub_match<BiIter>::string_type(rhs.data(), rhs.size()))
+      <=> 0
+    )
 ```
 ``` cpp
 template<class BiIter>
   bool operator==(const sub_match<BiIter>& lhs,
                   const typename iterator_traits<BiIter>::value_type* rhs);
 ```
 *Returns:* `lhs.compare(rhs) == 0`.
 ``` cpp
 template<class BiIter>
+ auto operator<=>(const sub_match<BiIter>& lhs,
                    const typename iterator_traits<BiIter>::value_type* rhs);
 ```
+*Returns:* `static_cast<`*`SM-CAT`*`(BiIter)>(lhs.compare(rhs) <=> 0)`.
 ``` cpp
 template<class BiIter>
   bool operator==(const sub_match<BiIter>& lhs,
                   const typename iterator_traits<BiIter>::value_type& rhs);
 *Returns:*
 `lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) == 0`.
 ``` cpp
 template<class BiIter>
+ auto operator<=>(const sub_match<BiIter>& lhs,
                    const typename iterator_traits<BiIter>::value_type& rhs);
 ```
 *Returns:*
 ``` cpp
+static_cast<SM-CAT(BiIter)>(lhs.compare(
+    typename sub_match<BiIter>::string_type(1, rhs))
+ <=> 0
+    )
 ```
 ``` cpp
 template<class charT, class ST, class BiIter>
   basic_ostream<charT, ST>&
     operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
 ```
 Class template `match_results` denotes a collection of character
 sequences representing the result of a regular expression match. Storage
 for the collection is allocated and freed as necessary by the member
 functions of class template `match_results`.
+The class template `match_results` meets the requirements of an
 allocator-aware container and of a sequence container (
 [[container.requirements.general]], [[sequence.reqmts]]) except that
+only copy assignment, move assignment, and operations defined for
+const-qualified sequence containers are supported and that the semantics
+of comparison functions are different from those required for a
+container.
 A default-constructed `match_results` object has no fully established
 result state. A match result is *ready* when, as a consequence of a
 completed regular expression match modifying such an object, its result
 state becomes fully established. The effects of calling most member
       using char_type       =
               typename iterator_traits<BidirectionalIterator>::value_type;
       using string_type     = basic_string<char_type>;
       // [re.results.const], construct/copy/destroy
+      match_results() : match_results(Allocator()) {}
+      explicit match_results(const Allocator&);
       match_results(const match_results& m);
       match_results(match_results&& m) noexcept;
       match_results& operator=(const match_results& m);
       match_results& operator=(match_results&& m);
       ~match_results();
       bool ready() const;
       // [re.results.size], size
       size_type size() const;
       size_type max_size() const;
+ [[nodiscard]] bool empty() const;
       // [re.results.acc], element access
       difference_type length(size_type sub = 0) const;
       difference_type position(size_type sub = 0) const;
       string_type str(size_type sub = 0) const;
       void swap(match_results& that);
     };
 }
 ```
+### Constructors <a id="re.results.const">[[re.results.const]]</a>
 ``` cpp
+explicit match_results(const Allocator& a);
 ```
+*Ensures:* `ready()` returns `false`. `size()` returns `0`.
 ``` cpp
 match_results(match_results&& m) noexcept;
 ```
+*Effects:* The stored `Allocator` value is move constructed from
 `m.get_allocator()`.
+*Ensures:* As specified in [[re.results.const]].
 ``` cpp
 match_results& operator=(const match_results& m);
 ```
+*Ensures:* As specified in [[re.results.const]].
 ``` cpp
 match_results& operator=(match_results&& m);
 ```
+*Ensures:* As specified in [[re.results.const]].
+**Table: `match_results` assignment operator effects** <a id="re.results.const">[re.results.const]</a>
 | Element       | Value                                           |
 | ------------- | ----------------------------------------------- |
 | `ready()`     | `m.ready()`                                     |
 | `size()`      | `m.size()`                                      |
 | `(*this)[n]`  | `m[n]` for all integers `n < m.size()`          |
 | `length(n)`   | `m.length(n)` for all integers `n < m.size()`   |
 | `position(n)` | `m.position(n)` for all integers `n < m.size()` |
+### State <a id="re.results.state">[[re.results.state]]</a>
 ``` cpp
 bool ready() const;
 ```
 *Returns:* `true` if `*this` has a fully established result state,
 otherwise `false`.
+### Size <a id="re.results.size">[[re.results.size]]</a>
 ``` cpp
 size_type size() const;
 ```
 expression that was matched if `*this` represents the result of a
 successful match. Otherwise returns `0`.
 [*Note 1*: The state of a `match_results` object can be modified only
 by passing that object to `regex_match` or `regex_search`.
+Subclauses  [[re.alg.match]] and  [[re.alg.search]] specify the effects
+of those algorithms on their `match_results` arguments. — *end note*]
 ``` cpp
 size_type max_size() const;
 ```
 *Returns:* The maximum number of `sub_match` elements that can be stored
 in `*this`.
 ``` cpp
+[[nodiscard]] bool empty() const;
 ```
 *Returns:* `size() == 0`.
+### Element access <a id="re.results.acc">[[re.results.acc]]</a>
 ``` cpp
 difference_type length(size_type sub = 0) const;
 ```
+*Preconditions:* `ready() == true`.
 *Returns:* `(*this)[sub].length()`.
 ``` cpp
 difference_type position(size_type sub = 0) const;
 ```
+*Preconditions:* `ready() == true`.
 *Returns:* The distance from the start of the target sequence to
 `(*this)[sub].first`.
 ``` cpp
 string_type str(size_type sub = 0) const;
 ```
+*Preconditions:* `ready() == true`.
 *Returns:* `string_type((*this)[sub])`.
 ``` cpp
 const_reference operator[](size_type n) const;
 ```
+*Preconditions:* `ready() == true`.
 *Returns:* A reference to the `sub_match` object representing the
 character sequence that matched marked sub-expression `n`. If `n == 0`
 then returns a reference to a `sub_match` object representing the
 character sequence that matched the whole regular expression. If
 ``` cpp
 const_reference prefix() const;
 ```
+*Preconditions:* `ready() == true`.
 *Returns:* A reference to the `sub_match` object representing the
 character sequence from the start of the string being matched/searched
 to the start of the match found.
 ``` cpp
 const_reference suffix() const;
 ```
+*Preconditions:* `ready() == true`.
 *Returns:* A reference to the `sub_match` object representing the
 character sequence from the end of the match found to the end of the
 string being matched/searched.
 ```
 *Returns:* A terminating iterator that enumerates over all the
 sub-expressions stored in `*this`.
+### Formatting <a id="re.results.form">[[re.results.form]]</a>
 ``` cpp
 template<class OutputIter>
   OutputIter format(
       OutputIter out,
       const char_type* fmt_first, const char_type* fmt_last,
       regex_constants::match_flag_type flags = regex_constants::format_default) const;
 ```
+*Preconditions:* `ready() == true` and `OutputIter` meets the
+requirements for a *Cpp17OutputIterator*[[output.iterators]].
 *Effects:* Copies the character sequence \[`fmt_first`, `fmt_last`) to
 OutputIter `out`. Replaces each format specifier or escape sequence in
 the copied range with either the character(s) it represents or the
 sequence of characters within `*this` to which it refers. The bitmasks
   basic_string<char_type, ST, SA> format(
       const basic_string<char_type, ST, SA>& fmt,
       regex_constants::match_flag_type flags = regex_constants::format_default) const;
 ```
+*Preconditions:* `ready() == true`.
 *Effects:* Constructs an empty string `result` of type
 `basic_string<char_type, ST, SA>` and calls:
 ``` cpp
 string_type format(
     const char_type* fmt,
     regex_constants::match_flag_type flags = regex_constants::format_default) const;
 ```
+*Preconditions:* `ready() == true`.
 *Effects:* Constructs an empty string `result` of type `string_type` and
 calls:
 ``` cpp
 format(back_inserter(result), fmt, fmt + char_traits<char_type>::length(fmt), flags);
 ```
 *Returns:* `result`.
+### Allocator <a id="re.results.all">[[re.results.all]]</a>
 ``` cpp
 allocator_type get_allocator() const;
 ```
 *Returns:* A copy of the Allocator that was passed to the object’s
 constructor or, if that allocator has been replaced, a copy of the most
 recent replacement.
+### Swap <a id="re.results.swap">[[re.results.swap]]</a>
 ``` cpp
 void swap(match_results& that);
 ```
 *Effects:* Swaps the contents of the two sequences.
+*Ensures:* `*this` contains the sequence of matched sub-expressions that
+were in `that`, `that` contains the sequence of matched sub-expressions
+that were in `*this`.
 *Complexity:* Constant time.
 ``` cpp
 template<class BidirectionalIterator, class Allocator>
             match_results<BidirectionalIterator, Allocator>& m2);
 ```
 *Effects:* As if by `m1.swap(m2)`.
+### Non-member functions <a id="re.results.nonmember">[[re.results.nonmember]]</a>
 ``` cpp
 template<class BidirectionalIterator, class Allocator>
 bool operator==(const match_results<BidirectionalIterator, Allocator>& m1,
                 const match_results<BidirectionalIterator, Allocator>& m2);
   - `m1.size() == m2.size() && equal(m1.begin(), m1.end(), m2.begin())`,
     and
   - `m1.suffix() == m2.suffix()`.
 [*Note 1*: The algorithm `equal` is defined in
+[[algorithms]]. — *end note*]
 ## Regular expression algorithms <a id="re.alg">[[re.alg]]</a>
 ### Exceptions <a id="re.except">[[re.except]]</a>
+The algorithms described in subclause  [[re.alg]] may throw an exception
+of type `regex_error`. If such an exception `e` is thrown, `e.code()`
+shall return either `regex_constants::error_complexity` or
 `regex_constants::error_stack`.
 ### `regex_match` <a id="re.alg.match">[[re.alg.match]]</a>
 ``` cpp
                    match_results<BidirectionalIterator, Allocator>& m,
                    const basic_regex<charT, traits>& e,
                    regex_constants::match_flag_type flags = regex_constants::match_default);
 ```
+*Preconditions:* `BidirectionalIterator` meets the
+*Cpp17BidirectionalIterator* requirements [[bidirectional.iterators]].
 *Effects:* Determines whether there is a match between the regular
 expression `e`, and all of the character sequence \[`first`, `last`).
 The parameter `flags` is used to control how the expression is matched
 against the character sequence. When determining if there is a match,
 regex_match ("GetValues", m, re);       // returns false
 ```
 — *end example*]
+*Ensures:* `m.ready() == true` in all cases. If the function returns
+`false`, then the effect on parameter `m` is unspecified except that
+`m.size()` returns `0` and `m.empty()` returns `true`. Otherwise the
+effects on parameter `m` are given in [[re.alg.match]].
+**Table: Effects of `regex_match` algorithm** <a id="re.alg.match">[re.alg.match]</a>
 | Element              | Value                                                                                                                                                                               |
 | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `m.size()`           | `1 + e.mark_count()`                                                                                                                                                                |
 | `m.empty()`          | `false`                                                                                                                                                                             |
                     match_results<BidirectionalIterator, Allocator>& m,
                     const basic_regex<charT, traits>& e,
                     regex_constants::match_flag_type flags = regex_constants::match_default);
 ```
+*Preconditions:* `BidirectionalIterator` meets the
+*Cpp17BidirectionalIterator* requirements [[bidirectional.iterators]].
 *Effects:* Determines whether there is some sub-sequence within
 \[`first`, `last`) that matches the regular expression `e`. The
 parameter `flags` is used to control how the expression is matched
 against the character sequence. Returns `true` if such a sequence
 exists, `false` otherwise.
+*Ensures:* `m.ready() == true` in all cases. If the function returns
+`false`, then the effect on parameter `m` is unspecified except that
+`m.size()` returns `0` and `m.empty()` returns `true`. Otherwise the
+effects on parameter `m` are given in [[re.alg.search]].
+**Table: Effects of `regex_search` algorithm** <a id="re.alg.search">[re.alg.search]</a>
 | Element              | Value                                                                                                                                                                               |
 | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `m.size()`           | `1 + e.mark_count()`                                                                                                                                                                |
 | `m.empty()`          | `false`                                                                                                                                                                             |
                      const regex_type&&,
                      regex_constants::match_flag_type = regex_constants::match_default) = delete;
       regex_iterator(const regex_iterator&);
       regex_iterator& operator=(const regex_iterator&);
       bool operator==(const regex_iterator&) const;
       const value_type& operator*() const;
       const value_type* operator->() const;
       regex_iterator& operator++();
       regex_iterator operator++(int);
 [*Note 1*: For example, this can occur when the part of the regular
 expression that matched consists only of an assertion (such as `'^'`,
 `'$'`, `'\b'`, `'\B'`). — *end note*]
+#### Constructors <a id="re.regiter.cnstr">[[re.regiter.cnstr]]</a>
 ``` cpp
 regex_iterator();
 ```
                const regex_type& re,
                regex_constants::match_flag_type m = regex_constants::match_default);
 ```
 *Effects:* Initializes `begin` and `end` to `a` and `b`, respectively,
+sets `pregex` to `addressof(re)`, sets `flags` to `m`, then calls
 `regex_search(begin, end, match, *pregex, flags)`. If this call returns
 `false` the constructor sets `*this` to the end-of-sequence iterator.
+#### Comparisons <a id="re.regiter.comp">[[re.regiter.comp]]</a>
 ``` cpp
 bool operator==(const regex_iterator& right) const;
 ```
 - `flags == right.flags`, and
 - `match[0] == right.match[0]`;
 otherwise `false`.
+#### Indirection <a id="re.regiter.deref">[[re.regiter.deref]]</a>
 ``` cpp
 const value_type& operator*() const;
 ```
 ``` cpp
 const value_type* operator->() const;
 ```
+*Returns:* `addressof(match)`.
+#### Increment <a id="re.regiter.incr">[[re.regiter.incr]]</a>
 ``` cpp
 regex_iterator& operator++();
 ```
 `regex_search`. — *end note*]
 It is unspecified how the implementation makes these adjustments.
 [*Note 2*: This means that a compiler may call an
+implementation-specific search function, in which case a program-defined
 specialization of `regex_search` will not be called. — *end note*]
 ``` cpp
 regex_iterator operator++(int);
 ```
                            regex_constants::match_flag_type m =
                              regex_constants::match_default) = delete;
       regex_token_iterator(const regex_token_iterator&);
       regex_token_iterator& operator=(const regex_token_iterator&);
       bool operator==(const regex_token_iterator&) const;
       const value_type& operator*() const;
       const value_type* operator->() const;
       regex_token_iterator& operator++();
       regex_token_iterator operator++(int);
 `suffix.first` points to the beginning of the final sequence, and
 `suffix.second` points to the end of the final sequence.
 [*Note 1*: For a suffix iterator, data member `suffix.first` is the
 same as the end of the last match found, and `suffix.second` is the same
+as the end of the target sequence. — *end note*]
 The *current match* is `(*position).prefix()` if `subs[N] == -1`, or
 `(*position)[subs[N]]` for any other value of `subs[N]`.
+#### Constructors <a id="re.tokiter.cnstr">[[re.tokiter.cnstr]]</a>
 ``` cpp
 regex_token_iterator();
 ```
                        const regex_type& re,
                        const int (&submatches)[N],
                        regex_constants::match_flag_type m = regex_constants::match_default);
 ```
+*Preconditions:* Each of the initialization values of `submatches` is
 `>= -1`.
 *Effects:* The first constructor initializes the member `subs` to hold
+the single value `submatch`. The second, third, and fourth constructors
+initialize the member `subs` to hold a copy of the sequence of integer
+values pointed to by the iterator range \[`begin(submatches)`,
+`end(submatches)`).
 Each constructor then sets `N` to 0, and `position` to
 `position_iterator(a, b, re, m)`. If `position` is not an
 end-of-sequence iterator the constructor sets `result` to the address of
 the current match. Otherwise if any of the values stored in `subs` is
 equal to -1 the constructor sets `*this` to a suffix iterator that
 points to the range \[`a`, `b`), otherwise the constructor sets `*this`
 to an end-of-sequence iterator.
+#### Comparisons <a id="re.tokiter.comp">[[re.tokiter.comp]]</a>
 ``` cpp
 bool operator==(const regex_token_iterator& right) const;
 ```
 `suffix == right.suffix`; otherwise returns `false` if `*this` or
 `right` is an end-of-sequence iterator or a suffix iterator. Otherwise
 returns `true` if `position == right.position`, `N == right.N`, and
 `subs == right.subs`. Otherwise returns `false`.
+#### Indirection <a id="re.tokiter.deref">[[re.tokiter.deref]]</a>
 ``` cpp
 const value_type& operator*() const;
 ```
 const value_type* operator->() const;
 ```
 *Returns:* `result`.
+#### Increment <a id="re.tokiter.incr">[[re.tokiter.incr]]</a>
 ``` cpp
 regex_token_iterator& operator++();
 ```
 the appropriate traits member function to achieve the required effect.
 The following productions within the ECMAScript grammar are modified as
 follows:
+``` bnf
 ClassAtom::
+ '-'
   ClassAtomNoDash
   ClassAtomExClass
   ClassAtomCollatingElement
   ClassAtomEquivalence
 IdentityEscape::
+  SourceCharacter but not 'c'
 ```
 The following new productions are then added:
+``` bnf
 ClassAtomExClass::
+ '[:' ClassName ':]'
 ClassAtomCollatingElement::
+ '[.' ClassName '.]'
 ClassAtomEquivalence::
+ '[=' ClassName '=]'
 ClassName::
   ClassNameCharacter
   ClassNameCharacter ClassName
 ClassNameCharacter::
+  SourceCharacter but not one of '.' or '=' or ':'
 ```
+The productions , and provide functionality equivalent to that of the
 same features in regular expressions in POSIX.
 The regular expression grammar may be modified by any
 `regex_constants::syntax_option_type` flags specified when constructing
 an object of type specialization of `basic_regex` according to the rules
+in [[re.synopt]].
+A production, when used in , is not valid if
+`traits_inst.lookup_classname` returns zero for that name. The names
+recognized as valid s are determined by the type of the traits class,
+but at least the following names shall be recognized: `alnum`, `alpha`,
+`blank`, `cntrl`, `digit`, `graph`, `lower`, `print`, `punct`, `space`,
+`upper`, `xdigit`, `d`, `s`, `w`. In addition the following expressions
+shall be equivalent:
 ``` cpp
 \d and [[:digit:]]
 \D and [^[:digit:]]
 \w and [_[:alnum:]]
 \W and [^_[:alnum:]]
 ```
+A production when used in a production is not valid if the value
+returned by `traits_inst.lookup_collatename` for that name is an empty
+string.
 The results from multiple calls to `traits_inst.lookup_classname` can be
+bitwise ’ed together and subsequently passed to `traits_inst.isctype`.
+A production when used in a production is not valid if the value
+returned by `traits_inst.lookup_collatename` for that name is an empty
+string or if the value returned by `traits_inst.transform_primary` for
+the result of the call to `traits_inst.lookup_collatename` is an empty
+string.
 When the sequence of characters being transformed to a finite state
 machine contains an invalid class name the translator shall throw an
 exception object of type `regex_error`.
 sequence of characters to an integral value, this is accomplished by
 calling `traits_inst.value`.
 The behavior of the internal finite state machine representation when
 used to match a sequence of characters is as described in ECMA-262. The
+behavior is modified according to any `match_flag_type` flags
+[[re.matchflag]] specified when using the regular expression object in
+one of the regular expression algorithms [[re.alg]]. The behavior is
 also localized by interaction with the traits class template parameter
 as follows:
 - During matching of a regular expression finite state machine against a
   sequence of characters, two characters `c` and `d` are compared using
     `traits_inst.translate(c) == traits_inst.translate(d)`;
   - otherwise, the two characters are equal if `c == d`.
 - During matching of a regular expression finite state machine against a
   sequence of characters, comparison of a collating element range
   `c1-c2` against a character `c` is conducted as follows: if
+  `flags() & regex_constants::collate` is `false` then the character `c`
   is matched if `c1
   <= c && c <= c2`, otherwise `c` is matched in accordance with the
   following algorithm:
   ``` cpp
   string_type str1 = string_type(1,
     flags() & icase ?
+      traits_inst.translate_nocase(c1) : traits_inst.translate(c1));
   string_type str2 = string_type(1,
     flags() & icase ?
+      traits_inst.translate_nocase(c2) : traits_inst.translate(c2));
   string_type str = string_type(1,
     flags() & icase ?
+      traits_inst.translate_nocase(c) : traits_inst.translate(c));
   return traits_inst.transform(str1.begin(), str1.end())
         <= traits_inst.transform(str.begin(), str.end())
     && traits_inst.transform(str.begin(), str.end())
         <= traits_inst.transform(str2.begin(), str2.end());
   ```
   sequence of characters, a character `c` is a member of a character
   class designated by an iterator range \[`first`, `last`) if
   `traits_inst.isctype(c, traits_inst.lookup_classname(first, last, flags() & icase))`
   is `true`.
+ECMA-262 15.10
 <!-- Link reference definitions -->
 [algorithms]: algorithms.md#algorithms
 [bidirectional.iterators]: iterators.md#bidirectional.iterators
 [bitmask.types]: library.md#bitmask.types
 [container.requirements.general]: containers.md#container.requirements.general
 [re.grammar]: #re.grammar
 [re.iter]: #re.iter
 [re.matchflag]: #re.matchflag
 [re.regex]: #re.regex
 [re.regex.assign]: #re.regex.assign
 [re.regex.construct]: #re.regex.construct
 [re.regex.locale]: #re.regex.locale
 [re.regex.nonmemb]: #re.regex.nonmemb
 [re.regex.operations]: #re.regex.operations
 [re.regex.swap]: #re.regex.swap
 [re.regiter]: #re.regiter
 [re.regiter.cnstr]: #re.regiter.cnstr
 [re.results.state]: #re.results.state
 [re.results.swap]: #re.results.swap
 [re.submatch]: #re.submatch
 [re.submatch.members]: #re.submatch.members
 [re.submatch.op]: #re.submatch.op
+[re.summary]: #re.summary
 [re.syn]: #re.syn
 [re.synopt]: #re.synopt
 [re.tokiter]: #re.tokiter
 [re.tokiter.cnstr]: #re.tokiter.cnstr
 [re.tokiter.comp]: #re.tokiter.comp
 [re.tokiter.deref]: #re.tokiter.deref
 [re.tokiter.incr]: #re.tokiter.incr
 [re.traits]: #re.traits
+[re.traits.classnames]: #re.traits.classnames
 [sequence.reqmts]: containers.md#sequence.reqmts
 [strings.general]: strings.md#strings.general
 [^1]: For example, if the parameter `icase` is `true` then `[[:lower:]]`
     is the same as `[[:alpha:]]`.

Diff to HTML by rtfpessoa