[strings] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpzd7jj6sx/{from.md → to.md} +263 -500

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

@@ -1,13 +1,15 @@
 # Strings library <a id="strings">[[strings]]</a>
 ## General <a id="strings.general">[[strings.general]]</a>
 This Clause describes components for manipulating sequences of any
-non-array trivial standard-layout [[term.standard.layout.type]] type.
-Such types are called *char-like types*, and objects of char-like types
-are called *char-like objects* or simply *characters*.
 The following subclauses describe a character traits class, string
 classes, and null-terminated sequence utilities, as summarized in
 [[strings.summary]].
@@ -43,11 +45,11 @@ functions for the character container type `C`; `c` and `d` denote
 values of type `C`; `p` and `q` denote values of type `const C*`; `s`
 denotes a value of type `C*`; `n`, `i` and `j` denote values of type
 `size_t`; `e` and `f` denote values of type `X::int_type`; `pos` denotes
 a value of type `X::pos_type`; and `r` denotes an lvalue of type `C`. No
 expression which is part of the character traits requirements specified
-in this subclause [[char.traits.require]] shall exit via an exception.
 The class template
 ``` cpp
 template<class charT> struct char_traits;
@@ -312,37 +314,37 @@ own implicit conversions to `std::basic_string_view<charT>` in order to
 interoperate with these functions. — *end note*]
 ### Header `<string_view>` synopsis <a id="string.view.synop">[[string.view.synop]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
 namespace std {
   // [string.view.template], class template basic_string_view
   template<class charT, class traits = char_traits<charT>>
-  class basic_string_view;
   template<class charT, class traits>
-    constexpr bool ranges::enable_view<basic_string_view<charT, traits>> = true;
   template<class charT, class traits>
-    constexpr bool ranges::enable_borrowed_range<basic_string_view<charT, traits>> = true;
   // [string.view.comparison], non-member comparison functions
   template<class charT, class traits>
     constexpr bool operator==(basic_string_view<charT, traits> x,
-                              basic_string_view<charT, traits> y) noexcept;
   template<class charT, class traits>
     constexpr see below operator<=>(basic_string_view<charT, traits> x,
-              \itcorr                      basic_string_view<charT, traits> y) noexcept;
-  // see [string.view.comparison], sufficient additional overloads of comparison functions
   // [string.view.io], inserters and extractors
   template<class charT, class traits>
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& os,
-                 basic_string_view<charT, traits> str);
   // basic_string_view typedef-names
   using string_view    = basic_string_view<char>;
   using u8string_view  = basic_string_view<char8_t>;
   using u16string_view = basic_string_view<char16_t>;
@@ -421,36 +423,43 @@ namespace std {
     // [string.view.capacity], capacity
     constexpr size_type size() const noexcept;
     constexpr size_type length() const noexcept;
     constexpr size_type max_size() const noexcept;
- [[nodiscard]] constexpr bool empty() const noexcept;
     // [string.view.access], element access
     constexpr const_reference operator[](size_type pos) const;
-    constexpr const_reference at(size_type pos) const;
     constexpr const_reference front() const;
     constexpr const_reference back() const;
     constexpr const_pointer data() const noexcept;
     // [string.view.modifiers], modifiers
     constexpr void remove_prefix(size_type n);
     constexpr void remove_suffix(size_type n);
     constexpr void swap(basic_string_view& s) noexcept;
     // [string.view.ops], string operations
-    constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
-    constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
     constexpr int compare(basic_string_view s) const noexcept;
-    constexpr int compare(size_type pos1, size_type n1, basic_string_view s) const;
     constexpr int compare(size_type pos1, size_type n1, basic_string_view s,
-                          size_type pos2, size_type n2) const;
     constexpr int compare(const charT* s) const;
-    constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
-    constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
     constexpr bool starts_with(basic_string_view x) const noexcept;
     constexpr bool starts_with(charT x) const noexcept;
     constexpr bool starts_with(const charT* x) const;
     constexpr bool ends_with(basic_string_view x) const noexcept;
@@ -514,15 +523,14 @@ same type as `charT`. — *end note*]
 For a `basic_string_view str`, any operation that invalidates a pointer
 in the range
 ``` cpp
-{[}str.data(), {str.data() + str.size()}{)}
 ```
-invalidates pointers, iterators, and references returned from `str`’s
-member functions.
 The complexity of `basic_string_view` member functions is 𝑂(1) unless
 otherwise specified.
 `basic_string_view<charT, traits>` is a trivially copyable type
@@ -532,31 +540,31 @@ otherwise specified.
 ``` cpp
 constexpr basic_string_view() noexcept;
 ```
-*Ensures:* `size_ == 0` and `data_ == nullptr`.
 ``` cpp
 constexpr basic_string_view(const charT* str);
 ```
 *Preconditions:* \[`str`, `str + traits::length(str)`) is a valid range.
-*Effects:* Constructs a `basic_string_view`, initializing `data_` with
-`str` and initializing `size_` with `traits::length(str)`.
 *Complexity:* 𝑂(`traits::length(str)`).
 ``` cpp
 constexpr basic_string_view(const charT* str, size_type len);
 ```
 *Preconditions:* \[`str`, `str + len`) is a valid range.
-*Effects:* Constructs a `basic_string_view`, initializing `data_` with
-`str` and initializing `size_` with `len`.
 ``` cpp
 template<class It, class End>
   constexpr basic_string_view(It begin, End end);
 ```
@@ -572,12 +580,12 @@ template<class It, class End>
 - \[`begin`, `end`) is a valid range.
 - `It` models `contiguous_iterator`.
 - `End` models `sized_sentinel_for<It>`.
-*Effects:* Initializes `data_` with `to_address(begin)` and initializes
-`size_` with `end - begin`.
 *Throws:* When and what `end - begin` throws.
 ``` cpp
 template<class R>
@@ -593,11 +601,11 @@ Let `d` be an lvalue of type `remove_cvref_t<R>`.
 - `is_same_v<ranges::range_value_t<R>, charT>` is `true`,
 - `is_convertible_v<R, const charT*>` is `false`, and
 - `d.operator ::std::basic_string_view<charT, traits>()` is not a valid
   expression.
-*Effects:* Initializes `data_` with `ranges::data(r)` and `size_` with
 `ranges::size(r)`.
 *Throws:* Any exception thrown by `ranges::data(r)` and
 `ranges::size(r)`.
@@ -640,11 +648,11 @@ constexpr const_iterator begin() const noexcept;
 constexpr const_iterator cbegin() const noexcept;
 ```
 *Returns:* An iterator such that
-- if `!empty()`, `addressof(*begin()) == data_`,
 - otherwise, an unspecified value such that \[`begin()`, `end()`) is a
   valid range.
 ``` cpp
 constexpr const_iterator end() const noexcept;
@@ -672,74 +680,73 @@ constexpr const_reverse_iterator crend() const noexcept;
 ``` cpp
 constexpr size_type size() const noexcept;
 constexpr size_type length() const noexcept;
 ```
-*Returns:* `size_`.
 ``` cpp
 constexpr size_type max_size() const noexcept;
 ```
 *Returns:* The largest possible number of char-like objects that can be
 referred to by a `basic_string_view`.
 ``` cpp
-[[nodiscard]] constexpr bool empty() const noexcept;
 ```
-*Returns:* `size_ == 0`.
 #### Element access <a id="string.view.access">[[string.view.access]]</a>
 ``` cpp
 constexpr const_reference operator[](size_type pos) const;
 ```
-*Preconditions:* `pos < size()`.
-*Returns:* `data_[pos]`.
 *Throws:* Nothing.
-[*Note 1*: Unlike `basic_string::operator[]`,
-`basic_string_view::operator[](size())` has undefined behavior instead
-of returning `charT()`. — *end note*]
 ``` cpp
 constexpr const_reference at(size_type pos) const;
 ```
-*Returns:* `data_[pos]`.
 *Throws:* `out_of_range` if `pos >= size()`.
 ``` cpp
 constexpr const_reference front() const;
 ```
-*Preconditions:* `!empty()`.
-*Returns:* `data_[0]`.
 *Throws:* Nothing.
 ``` cpp
 constexpr const_reference back() const;
 ```
-*Preconditions:* `!empty()`.
-*Returns:* `data_[size() - 1]`.
 *Throws:* Nothing.
 ``` cpp
 constexpr const_pointer data() const noexcept;
 ```
-*Returns:* `data_`.
 [*Note 2*: Unlike `basic_string::data()` and *string-literal*s,
 `data()` can return a pointer to a buffer that is not null-terminated.
 Therefore it is typically a mistake to pass `data()` to a function that
 takes just a `const charT*` and expects a null-terminated
@@ -749,21 +756,21 @@ string. — *end note*]
 ``` cpp
 constexpr void remove_prefix(size_type n);
 ```
-*Preconditions:* `n <= size()`.
-*Effects:* Equivalent to: `data_ += n; size_ -= n;`
 ``` cpp
 constexpr void remove_suffix(size_type n);
 ```
-*Preconditions:* `n <= size()`.
-*Effects:* Equivalent to: `size_ -= n;`
 ``` cpp
 constexpr void swap(basic_string_view& s) noexcept;
 ```
@@ -787,10 +794,11 @@ Let `rlen` be the smaller of `n` and `size() - pos`.
 *Complexity:* 𝑂(`rlen`).
 ``` cpp
 constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
 ```
 Let `rlen` be the smaller of `n` and `size() - pos`.
 *Effects:* Determines `rlen`, the effective length of the string to
@@ -861,11 +869,13 @@ constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2
 ``` cpp
 constexpr bool starts_with(basic_string_view x) const noexcept;
 ```
-*Effects:* Equivalent to: `return substr(0, x.size()) == x;`
 ``` cpp
 constexpr bool starts_with(charT x) const noexcept;
 ```
@@ -879,14 +889,16 @@ constexpr bool starts_with(const charT* x) const;
 ``` cpp
 constexpr bool ends_with(basic_string_view x) const noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return size() >= x.size() && compare(size() - x.size(), npos, x) == 0;
 ```
 ``` cpp
 constexpr bool ends_with(charT x) const noexcept;
 ```
@@ -943,12 +955,12 @@ constexpr size_type find(basic_string_view str, size_type pos = 0) const noexcep
 Let `xpos` be the lowest position, if possible, such that the following
 conditions hold:
 - `pos <= xpos`
 - `xpos + str.size() <= size()`
-- `traits::eq(at(xpos + I), str.at(I))` for all elements `I` of the
-  string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
@@ -960,12 +972,12 @@ constexpr size_type rfind(basic_string_view str, size_type pos = npos) const noe
 Let `xpos` be the highest position, if possible, such that the following
 conditions hold:
 - `xpos <= pos`
 - `xpos + str.size() <= size()`
-- `traits::eq(at(xpos + I), str.at(I))` for all elements `I` of the
-  string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
@@ -977,12 +989,12 @@ constexpr size_type find_first_of(basic_string_view str, size_type pos = 0) cons
 Let `xpos` be the lowest position, if possible, such that the following
 conditions hold:
 - `pos <= xpos`
 - `xpos < size()`
-- `traits::eq(at(xpos), str.at(I))` for some element `I` of the string
-  referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
@@ -994,12 +1006,12 @@ constexpr size_type find_last_of(basic_string_view str, size_type pos = npos) co
 Let `xpos` be the highest position, if possible, such that the following
 conditions hold:
 - `xpos <= pos`
 - `xpos < size()`
-- `traits::eq(at(xpos), str.at(I))` for some element `I` of the string
-  referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
@@ -1011,12 +1023,12 @@ constexpr size_type find_first_not_of(basic_string_view str, size_type pos = 0)
 Let `xpos` be the lowest position, if possible, such that the following
 conditions hold:
 - `pos <= xpos`
 - `xpos < size()`
-- `traits::eq(at(xpos), str.at(I))` for no element `I` of the string
-  referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
@@ -1028,87 +1040,48 @@ constexpr size_type find_last_not_of(basic_string_view str, size_type pos = npos
 Let `xpos` be the highest position, if possible, such that the following
 conditions hold:
 - `xpos <= pos`
 - `xpos < size()`
-- `traits::eq(at(xpos), str.at(I))` for no element `I` of the string
-  referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
 ### Non-member comparison functions <a id="string.view.comparison">[[string.view.comparison]]</a>
-Let `S` be `basic_string_view<charT, traits>`, and `sv` be an instance
-of `S`. Implementations shall provide sufficient additional overloads
-marked `constexpr` and `noexcept` so that an object `t` with an implicit
-conversion to `S` can be compared according to
-[[string.view.comparison.overloads]].
-**Table: Additional `basic_string_view` comparison overloads** <a id="string.view.comparison.overloads">[string.view.comparison.overloads]</a>
-| Expression | Equivalent to |
-| ---------- | ------------- |
-| `t == sv`  | `S(t) == sv`  |
-| `sv == t`  | `sv == S(t)`  |
-| `t != sv`  | `S(t) != sv`  |
-| `sv != t`  | `sv != S(t)`  |
-| `t < sv`   | `S(t) < sv`   |
-| `sv < t`   | `sv < S(t)`   |
-| `t > sv`   | `S(t) > sv`   |
-| `sv > t`   | `sv > S(t)`   |
-| `t <= sv`  | `S(t) <= sv`  |
-| `sv <= t`  | `sv <= S(t)`  |
-| `t >= sv`  | `S(t) >= sv`  |
-| `sv >= t`  | `sv >= S(t)`  |
-| `t <=> sv` | `S(t) <=> sv` |
-| `sv <=> t` | `sv <=> S(t)` |
-[*Example 1*:
-A sample conforming implementation for `operator==` would be:
 ``` cpp
 template<class charT, class traits>
   constexpr bool operator==(basic_string_view<charT, traits> lhs,
-                            basic_string_view<charT, traits> rhs) noexcept {
-    return lhs.compare(rhs) == 0;
-  }
-template<class charT, class traits>
-  constexpr bool operator==(basic_string_view<charT, traits> lhs,
-                            type_identity_t<basic_string_view<charT, traits>> rhs) noexcept {
-    return lhs.compare(rhs) == 0;
-  }
-```
-— *end example*]
-``` cpp
-template<class charT, class traits>
-  constexpr bool operator==(basic_string_view<charT, traits> lhs,
-                            basic_string_view<charT, traits> rhs) noexcept;
 ```
 *Returns:* `lhs.compare(rhs) == 0`.
 ``` cpp
 template<class charT, class traits>
   constexpr see below operator<=>(basic_string_view<charT, traits> lhs,
-            \itcorr                      basic_string_view<charT, traits> rhs) noexcept;
 ```
 Let `R` denote the type `traits::comparison_category` if that
 *qualified-id* is valid and denotes a type [[temp.deduct]], otherwise
 `R` is `weak_ordering`.
 *Mandates:* `R` denotes a comparison category type [[cmp.categories]].
 *Returns:* `static_cast<R>(lhs.compare(rhs) <=> 0)`.
 ### Inserters and extractors <a id="string.view.io">[[string.view.io]]</a>
 ``` cpp
 template<class charT, class traits>
   basic_ostream<charT, traits>&
@@ -1121,11 +1094,11 @@ sequence `seq`, initially consisting of the elements defined by the
 range \[`str.begin()`, `str.end()`). Determines padding for `seq` as
 described in  [[ostream.formatted.reqmts]]. Then inserts `seq` as if by
 calling `os.rdbuf()->sputn(seq, n)`, where `n` is the larger of
 `os.width()` and `str.size()`; then calls `os.width(0)`.
-*Returns:* `os`
 ### Hash support <a id="string.view.hash">[[string.view.hash]]</a>
 ``` cpp
 template<> struct hash<string_view>;
@@ -1190,16 +1163,16 @@ manipulating varying-length sequences of char-like objects and five
 #include <compare>              // see [compare.syn]
 #include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   // [char.traits], character traits
-  template<class charT> struct char_traits;
-  template<> struct char_traits<char>;
-  template<> struct char_traits<char8_t>;
-  template<> struct char_traits<char16_t>;
-  template<> struct char_traits<char32_t>;
-  template<> struct char_traits<wchar_t>;
   // [basic.string], basic_string
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_string;
@@ -1249,10 +1222,26 @@ namespace std {
                 charT rhs);
   template<class charT, class traits, class Allocator>
     constexpr basic_string<charT, traits, Allocator>
       operator+(basic_string<charT, traits, Allocator>&& lhs,
                 charT rhs);
   template<class charT, class traits, class Allocator>
     constexpr bool
       operator==(const basic_string<charT, traits, Allocator>& lhs,
                  const basic_string<charT, traits, Allocator>& rhs) noexcept;
@@ -1301,11 +1290,11 @@ namespace std {
     basic_istream<charT, traits>&
       getline(basic_istream<charT, traits>&& is,
               basic_string<charT, traits, Allocator>& str);
   // [string.erasure], erasure
-  template<class charT, class traits, class Allocator, class U>
     constexpr typename basic_string<charT, traits, Allocator>::size_type
       erase(basic_string<charT, traits, Allocator>& c, const U& value);
   template<class charT, class traits, class Allocator, class Predicate>
     constexpr typename basic_string<charT, traits, Allocator>::size_type
       erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred);
@@ -1413,14 +1402,14 @@ namespace std {
   public:
     // types
     using traits_type            = traits;
     using value_type             = charT;
     using allocator_type         = Allocator;
-    using size_type              = typename allocator_traits<Allocator>::size_type;
-    using difference_type        = typename allocator_traits<Allocator>::difference_type;
-    using pointer                = typename allocator_traits<Allocator>::pointer;
-    using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using iterator               = implementation-defined  // type of basic_string::iterator; // see [container.requirements]
     using const_iterator         = implementation-defined  // type of basic_string::const_iterator; // see [container.requirements]
@@ -1496,11 +1485,11 @@ namespace std {
     template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
     constexpr size_type capacity() const noexcept;
     constexpr void reserve(size_type res_arg);
     constexpr void shrink_to_fit();
     constexpr void clear() noexcept;
- [[nodiscard]] constexpr bool empty() const noexcept;
     // [string.access], element access
     constexpr const_reference operator[](size_type pos) const;
     constexpr reference       operator[](size_type pos);
     constexpr const_reference at(size_type n) const;
@@ -1662,10 +1651,12 @@ namespace std {
     constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
     constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
     constexpr basic_string substr(size_type pos = 0, size_type n = npos) const &;
     constexpr basic_string substr(size_type pos = 0, size_type n = npos) &&;
     template<class T>
       constexpr int compare(const T& t) const noexcept(see below);
     template<class T>
       constexpr int compare(size_type pos1, size_type n1, const T& t) const;
@@ -1735,24 +1726,23 @@ operation throws an exception object of type `length_error`.
 If any member function or operator of `basic_string` throws an
 exception, that function or operator has no other effect on the
 `basic_string` object.
-In every specialization `basic_string<charT, traits, Allocator>`, the
-type `allocator_traits<Allocator>::value_type` shall name the same type
-as `charT`. Every object of type
-`basic_string<charT, traits, Allocator>` uses an object of type
-`Allocator` to allocate and free storage for the contained `charT`
-objects as needed. The `Allocator` object used is obtained as described
-in [[container.requirements.general]]. In every specialization
 `basic_string<charT, traits, Allocator>`, the type `traits` shall meet
 the character traits requirements [[char.traits]].
 [*Note 1*: Every specialization
-`basic_string<charT, traits, Allocator>` is an allocator-aware
-container, but does not use the allocator’s `construct` and `destroy`
-member functions [[container.requirements.general]]. — *end note*]
 [*Note 2*: The program is ill-formed if `traits::char_type` is not the
 same type as `charT`. — *end note*]
 References, pointers, and iterators referring to the elements of a
@@ -1858,11 +1848,11 @@ is equal to `0`.
 ``` cpp
 constexpr basic_string(const charT* s, const Allocator& a = Allocator());
 ```
 *Constraints:* `Allocator` is a type that qualifies as an
-allocator [[container.requirements.general]].
 [*Note 1*: This affects class template argument
 deduction. — *end note*]
 *Effects:* Equivalent to: `basic_string(s, traits::length(s), a)`.
@@ -1870,11 +1860,11 @@ deduction. — *end note*]
 ``` cpp
 constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
 ```
 *Constraints:* `Allocator` is a type that qualifies as an
-allocator [[container.requirements.general]].
 [*Note 2*: This affects class template argument
 deduction. — *end note*]
 *Effects:* Constructs an object whose value consists of `n` copies of
@@ -1884,11 +1874,11 @@ deduction. — *end note*]
 template<class InputIterator>
   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
 ```
 *Constraints:* `InputIterator` is a type that qualifies as an input
-iterator [[container.requirements.general]].
 *Effects:* Constructs a string from the values in the range \[`begin`,
 `end`), as specified in [[sequence.reqmts]].
 ``` cpp
@@ -1926,11 +1916,11 @@ template<class InputIterator,
                     Allocator>;
 ```
 *Constraints:* `InputIterator` is a type that qualifies as an input
 iterator, and `Allocator` is a type that qualifies as an
-allocator [[container.requirements.general]].
 ``` cpp
 template<class charT,
          class traits,
          class Allocator = allocator<charT>>
@@ -1945,11 +1935,11 @@ template<class charT,
                const Allocator& = Allocator())
     -> basic_string<charT, traits, Allocator>;
 ```
 *Constraints:* `Allocator` is a type that qualifies as an
-allocator [[container.requirements.general]].
 ``` cpp
 constexpr basic_string& operator=(const basic_string& str);
 ```
@@ -1962,13 +1952,12 @@ Otherwise, replaces the value of `*this` with a copy of `str`.
 constexpr basic_string& operator=(basic_string&& str)
   noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
-*Effects:* Move assigns as a sequence
-container [[container.requirements]], except that iterators, pointers
-and references may be invalidated.
 *Returns:* `*this`.
 ``` cpp
 template<class T>
@@ -2134,14 +2123,14 @@ constexpr size_type capacity() const noexcept;
 constexpr void reserve(size_type res_arg);
 ```
 *Effects:* A directive that informs a `basic_string` of a planned change
 in size, so that the storage allocation can be managed accordingly.
-After `reserve()`, `capacity()` is greater or equal to the argument of
-`reserve` if reallocation happens; and equal to the previous value of
-`capacity()` otherwise. Reallocation happens at this point if and only
-if the current capacity is less than the argument of `reserve()`.
 *Throws:* `length_error` if `res_arg > max_size()` or any exceptions
 thrown by `allocator_traits` `<Allocator>::allocate`.
 ``` cpp
@@ -2172,11 +2161,11 @@ constexpr void clear() noexcept;
 ```
 *Effects:* Equivalent to: `erase(begin(), end());`
 ``` cpp
-[[nodiscard]] constexpr bool empty() const noexcept;
 ```
 *Effects:* Equivalent to: `return size() == 0;`
 #### Element access <a id="string.access">[[string.access]]</a>
@@ -2184,11 +2173,11 @@ constexpr void clear() noexcept;
 ``` cpp
 constexpr const_reference operator[](size_type pos) const;
 constexpr reference       operator[](size_type pos);
 ```
-*Preconditions:* `pos <= size()`.
 *Returns:* `*(begin() + pos)` if `pos < size()`. Otherwise, returns a
 reference to an object of type `charT` with value `charT()`, where
 modifying the object to any value other than `charT()` leads to
 undefined behavior.
@@ -2209,20 +2198,20 @@ constexpr reference       at(size_type pos);
 ``` cpp
 constexpr const charT& front() const;
 constexpr charT& front();
 ```
-*Preconditions:* `!empty()`.
 *Effects:* Equivalent to: `return operator[](0);`
 ``` cpp
 constexpr const charT& back() const;
 constexpr charT& back();
 ```
-*Preconditions:* `!empty()`.
 *Effects:* Equivalent to: `return operator[](size() - 1);`
 #### Modifiers <a id="string.modifiers">[[string.modifiers]]</a>
@@ -2352,11 +2341,11 @@ constexpr basic_string& append(size_type n, charT c);
 template<class InputIterator>
   constexpr basic_string& append(InputIterator first, InputIterator last);
 ```
 *Constraints:* `InputIterator` is a type that qualifies as an input
-iterator [[container.requirements.general]].
 *Effects:* Equivalent to:
 `return append(basic_string(first, last, get_allocator()));`
 ``` cpp
@@ -2480,11 +2469,11 @@ return *this;
 template<class InputIterator>
   constexpr basic_string& assign(InputIterator first, InputIterator last);
 ```
 *Constraints:* `InputIterator` is a type that qualifies as an input
-iterator [[container.requirements.general]].
 *Effects:* Equivalent to:
 `return assign(basic_string(first, last, get_allocator()));`
 ``` cpp
@@ -2580,11 +2569,11 @@ constexpr basic_string& insert(size_type pos, size_type n, charT c);
 ```
 *Effects:* Inserts `n` copies of `c` before the character at position
 `pos` if `pos < size()`, or otherwise at the end of the string.
-*Returns:* `*this`
 *Throws:*
 - `out_of_range` if `pos > size()`,
 - `length_error` if `n > max_size() - size()`, or
@@ -2615,11 +2604,11 @@ constexpr iterator insert(const_iterator p, size_type n, charT c);
 template<class InputIterator>
   constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
 ```
 *Constraints:* `InputIterator` is a type that qualifies as an input
-iterator [[container.requirements.general]].
 *Preconditions:* `p` is a valid iterator on `*this`.
 *Effects:* Equivalent to
 `insert(p - begin(), basic_string(first, last, get_allocator()))`.
@@ -2679,11 +2668,11 @@ constexpr iterator erase(const_iterator first, const_iterator last);
 ```
 *Preconditions:* `first` and `last` are valid iterators on `*this`.
 \[`first`, `last`) is a valid range.
-*Effects:* Removes the characters in the range `[first, last)`.
 *Returns:* An iterator which points to the element pointed to by `last`
 prior to the other elements being erased. If no such element exists,
 `end()` is returned.
@@ -2691,11 +2680,11 @@ prior to the other elements being erased. If no such element exists,
 ``` cpp
 constexpr void pop_back();
 ```
-*Preconditions:* `!empty()`.
 *Effects:* Equivalent to `erase(end() - 1)`.
 *Throws:* Nothing.
@@ -2797,12 +2786,12 @@ the function replaces the characters in the range \[`begin() + pos1`,
 *Returns:* `*this`.
 *Throws:*
 - `out_of_range` if `pos1 > size()`,
-- `length_error` if the length of the resulting string would
- exceed`max_size()`, or
 - any exceptions thrown by `allocator_traits<Allocator>::allocate.`
 ``` cpp
 constexpr basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
 ```
@@ -2857,11 +2846,11 @@ template<class InputIterator>
   constexpr basic_string& replace(const_iterator i1, const_iterator i2,
                                   InputIterator j1, InputIterator j2);
 ```
 *Constraints:* `InputIterator` is a type that qualifies as an input
-iterator [[container.requirements.general]].
 *Effects:* Equivalent to:
 `return replace(i1, i2, basic_string(j1, j2, get_allocator()));`
 ``` cpp
@@ -3037,10 +3026,17 @@ constexpr basic_string substr(size_type pos = 0, size_type n = npos) &&;
 ```
 *Effects:* Equivalent to:
 `return basic_string(std::move(*this), pos, n);`
 ##### `basic_string::compare` <a id="string.compare">[[string.compare]]</a>
 ``` cpp
 template<class T>
   constexpr int compare(const T& t) const noexcept(see below);
@@ -3324,10 +3320,74 @@ template<class charT, class traits, class Allocator>
 ``` cpp
 lhs.push_back(rhs);
 return std::move(lhs);
 ```
 #### Non-member comparison operator functions <a id="string.cmp">[[string.cmp]]</a>
 ``` cpp
 template<class charT, class traits, class Allocator>
   constexpr bool
@@ -3452,11 +3512,11 @@ template<class charT, class traits, class Allocator>
 *Returns:* `getline(is, str, is.widen(’\n’))`.
 #### Erasure <a id="string.erasure">[[string.erasure]]</a>
 ``` cpp
-template<class charT, class traits, class Allocator, class U>
   constexpr typename basic_string<charT, traits, Allocator>::size_type
     erase(basic_string<charT, traits, Allocator>& c, const U& value);
 ```
 *Effects:* Equivalent to:
@@ -3542,16 +3602,11 @@ string to_string(unsigned long long val);
 string to_string(float val);
 string to_string(double val);
 string to_string(long double val);
 ```
-*Returns:* Each function returns a `string` object holding the character
-representation of the value of its argument that would be generated by
-calling `sprintf(buf, fmt, val)` with a format specifier of `"%d"`,
-`"%u"`, `"%ld"`, `"%lu"`, `"%lld"`, `"%llu"`, `"%f"`, `"%f"`, or
-`"%Lf"`, respectively, where `buf` designates an internal character
-buffer of sufficient size.
 ``` cpp
 int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);
 long stol(const wstring& str, size_t* idx = nullptr, int base = 10);
 unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);
@@ -3606,16 +3661,11 @@ wstring to_wstring(unsigned long long val);
 wstring to_wstring(float val);
 wstring to_wstring(double val);
 wstring to_wstring(long double val);
 ```
-*Returns:* Each function returns a `wstring` object holding the
-character representation of the value of its argument that would be
-generated by calling `swprintf(buf, buffsz, fmt, val)` with a format
-specifier of `L"%d"`, `L"%u"`, `L"%ld"`, `L"%lu"`, `L"%lld"`, `L"%llu"`,
-`L"%f"`, `L"%f"`, or `L"%Lf"`, respectively, where `buf` designates an
-internal character buffer of sufficient size `buffsz`.
 ### Hash support <a id="basic.string.hash">[[basic.string.hash]]</a>
 ``` cpp
 template<class A> struct hash<basic_string<char, char_traits<char>, A>>;
@@ -3666,365 +3716,80 @@ denoting seconds but there is no conflict, since duration suffixes apply
 to numbers and string literal suffixes apply to character array
 literals. — *end note*]
 ## Null-terminated sequence utilities <a id="c.strings">[[c.strings]]</a>
-### Header `<cctype>` synopsis <a id="cctype.syn">[[cctype.syn]]</a>
-``` cpp
-namespace std {
-  int isalnum(int c);
-  int isalpha(int c);
-  int isblank(int c);
-  int iscntrl(int c);
-  int isdigit(int c);
-  int isgraph(int c);
-  int islower(int c);
-  int isprint(int c);
-  int ispunct(int c);
-  int isspace(int c);
-  int isupper(int c);
-  int isxdigit(int c);
-  int tolower(int c);
-  int toupper(int c);
-}
-```
-The contents and meaning of the header `<cctype>` are the same as the C
-standard library header `<ctype.h>`.
-See also: ISO C 7.4
-### Header `<cwctype>` synopsis <a id="cwctype.syn">[[cwctype.syn]]</a>
-``` cpp
-namespace std {
-  using wint_t = see below;
-  using wctrans_t = see below;
-  using wctype_t = see below;
-  int iswalnum(wint_t wc);
-  int iswalpha(wint_t wc);
-  int iswblank(wint_t wc);
-  int iswcntrl(wint_t wc);
-  int iswdigit(wint_t wc);
-  int iswgraph(wint_t wc);
-  int iswlower(wint_t wc);
-  int iswprint(wint_t wc);
-  int iswpunct(wint_t wc);
-  int iswspace(wint_t wc);
-  int iswupper(wint_t wc);
-  int iswxdigit(wint_t wc);
-  int iswctype(wint_t wc, wctype_t desc);
-  wctype_t wctype(const char* property);
-  wint_t towlower(wint_t wc);
-  wint_t towupper(wint_t wc);
-  wint_t towctrans(wint_t wc, wctrans_t desc);
-  wctrans_t wctrans(const char* property);
-}
-#define WEOF see below
-```
-The contents and meaning of the header `<cwctype>` are the same as the C
-standard library header `<wctype.h>`.
-See also: ISO C 7.30
 ### Header `<cstring>` synopsis <a id="cstring.syn">[[cstring.syn]]</a>
 ``` cpp
 namespace std {
-  using size_t = see [support.types.layout];
-  void* memcpy(void* s1, const void* s2, size_t n);
-  void* memmove(void* s1, const void* s2, size_t n);
- char* strcpy(char* s1, const char* s2);
-  char* strncpy(char* s1, const char* s2, size_t n);
-  char* strcat(char* s1, const char* s2);
-  char* strncat(char* s1, const char* s2, size_t n);
- int memcmp(const void* s1, const void* s2, size_t n);
- int strcmp(const char* s1, const char* s2);
   int strcoll(const char* s1, const char* s2);
-  int strncmp(const char* s1, const char* s2, size_t n);
   size_t strxfrm(char* s1, const char* s2, size_t n);
-  const void* memchr(const void* s, int c, size_t n); // see [library.c]
-  void* memchr(void* s, int c, size_t n); // see [library.c]
-  const char* strchr(const char* s, int c); // see [library.c]
-  char* strchr(char* s, int c); // see [library.c]
-  size_t strcspn(const char* s1, const char* s2);
-  const char* strpbrk(const char* s1, const char* s2); // see [library.c]
-  char* strpbrk(char* s1, const char* s2); // see [library.c]
-  const char* strrchr(const char* s, int c); // see [library.c]
-  char* strrchr(char* s, int c); // see [library.c]
-  size_t strspn(const char* s1, const char* s2);
-  const char* strstr(const char* s1, const char* s2); // see [library.c]
-  char* strstr(char* s1, const char* s2); // see [library.c]
   char* strtok(char* s1, const char* s2);
-  void* memset(void* s, int c, size_t n);
   char* strerror(int errnum);
-  size_t strlen(const char* s);
 }
-#define NULL see [support.types.nullptr]
 ```
 The contents and meaning of the header `<cstring>` are the same as the C
 standard library header `<string.h>`.
 The functions `strerror` and `strtok` are not required to avoid data
 races [[res.on.data.races]].
 The functions `memcpy` and `memmove` are signal-safe [[support.signal]].
-Both functions implicitly create objects [[intro.object]] in the
-destination region of storage immediately prior to copying the sequence
-of characters to the destination.
 [*Note 1*: The functions `strchr`, `strpbrk`, `strrchr`, `strstr`, and
 `memchr`, have different signatures in this document, but they have the
 same behavior as in the C standard library [[library.c]]. — *end note*]
-See also: ISO C 7.24
-### Header `<cwchar>` synopsis <a id="cwchar.syn">[[cwchar.syn]]</a>
-``` cpp
-namespace std {
-  using size_t = see [support.types.layout];
-  using mbstate_t = see below;
-  using wint_t = see below;
-  struct tm;
-  int fwprintf(FILE* stream, const wchar_t* format, ...);
-  int fwscanf(FILE* stream, const wchar_t* format, ...);
-  int swprintf(wchar_t* s, size_t n, const wchar_t* format, ...);
-  int swscanf(const wchar_t* s, const wchar_t* format, ...);
-  int vfwprintf(FILE* stream, const wchar_t* format, va_list arg);
-  int vfwscanf(FILE* stream, const wchar_t* format, va_list arg);
-  int vswprintf(wchar_t* s, size_t n, const wchar_t* format, va_list arg);
-  int vswscanf(const wchar_t* s, const wchar_t* format, va_list arg);
-  int vwprintf(const wchar_t* format, va_list arg);
-  int vwscanf(const wchar_t* format, va_list arg);
-  int wprintf(const wchar_t* format, ...);
-  int wscanf(const wchar_t* format, ...);
-  wint_t fgetwc(FILE* stream);
-  wchar_t* fgetws(wchar_t* s, int n, FILE* stream);
-  wint_t fputwc(wchar_t c, FILE* stream);
-  int fputws(const wchar_t* s, FILE* stream);
-  int fwide(FILE* stream, int mode);
-  wint_t getwc(FILE* stream);
-  wint_t getwchar();
-  wint_t putwc(wchar_t c, FILE* stream);
-  wint_t putwchar(wchar_t c);
-  wint_t ungetwc(wint_t c, FILE* stream);
-  double wcstod(const wchar_t* nptr, wchar_t** endptr);
-  float wcstof(const wchar_t* nptr, wchar_t** endptr);
-  long double wcstold(const wchar_t* nptr, wchar_t** endptr);
-  long int wcstol(const wchar_t* nptr, wchar_t** endptr, int base);
-  long long int wcstoll(const wchar_t* nptr, wchar_t** endptr, int base);
-  unsigned long int wcstoul(const wchar_t* nptr, wchar_t** endptr, int base);
-  unsigned long long int wcstoull(const wchar_t* nptr, wchar_t** endptr, int base);
-  wchar_t* wcscpy(wchar_t* s1, const wchar_t* s2);
-  wchar_t* wcsncpy(wchar_t* s1, const wchar_t* s2, size_t n);
-  wchar_t* wmemcpy(wchar_t* s1, const wchar_t* s2, size_t n);
-  wchar_t* wmemmove(wchar_t* s1, const wchar_t* s2, size_t n);
-  wchar_t* wcscat(wchar_t* s1, const wchar_t* s2);
-  wchar_t* wcsncat(wchar_t* s1, const wchar_t* s2, size_t n);
-  int wcscmp(const wchar_t* s1, const wchar_t* s2);
-  int wcscoll(const wchar_t* s1, const wchar_t* s2);
-  int wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t n);
-  size_t wcsxfrm(wchar_t* s1, const wchar_t* s2, size_t n);
-  int wmemcmp(const wchar_t* s1, const wchar_t* s2, size_t n);
-  const wchar_t* wcschr(const wchar_t* s, wchar_t c);           // see [library.c]
-  wchar_t* wcschr(wchar_t* s, wchar_t c);                       // see [library.c]
-  size_t wcscspn(const wchar_t* s1, const wchar_t* s2);
-  const wchar_t* wcspbrk(const wchar_t* s1, const wchar_t* s2); // see [library.c]
-  wchar_t* wcspbrk(wchar_t* s1, const wchar_t* s2);             // see [library.c]
-  const wchar_t* wcsrchr(const wchar_t* s, wchar_t c);          // see [library.c]
-  wchar_t* wcsrchr(wchar_t* s, wchar_t c);                      // see [library.c]
-  size_t wcsspn(const wchar_t* s1, const wchar_t* s2);
-  const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2);  // see [library.c]
-  wchar_t* wcsstr(wchar_t* s1, const wchar_t* s2);              // see [library.c]
-  wchar_t* wcstok(wchar_t* s1, const wchar_t* s2, wchar_t** ptr);
-  const wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n);    // see [library.c]
-  wchar_t* wmemchr(wchar_t* s, wchar_t c, size_t n);            // see [library.c]
-  size_t wcslen(const wchar_t* s);
-  wchar_t* wmemset(wchar_t* s, wchar_t c, size_t n);
-  size_t wcsftime(wchar_t* s, size_t maxsize, const wchar_t* format, const tm* timeptr);
-  wint_t btowc(int c);
-  int wctob(wint_t c);
-  // [c.mb.wcs], multibyte / wide string and character conversion functions
-  int mbsinit(const mbstate_t* ps);
-  size_t mbrlen(const char* s, size_t n, mbstate_t* ps);
-  size_t mbrtowc(wchar_t* pwc, const char* s, size_t n, mbstate_t* ps);
-  size_t wcrtomb(char* s, wchar_t wc, mbstate_t* ps);
-  size_t mbsrtowcs(wchar_t* dst, const char** src, size_t len, mbstate_t* ps);
-  size_t wcsrtombs(char* dst, const wchar_t** src, size_t len, mbstate_t* ps);
-}
-#define NULL see [support.types.nullptr]
-#define WCHAR_MAX see below
-#define WCHAR_MIN see below
-#define WEOF see below
-```
-The contents and meaning of the header `<cwchar>` are the same as the C
-standard library header `<wchar.h>`, except that it does not declare a
-type `wchar_t`.
-[*Note 1*: The functions `wcschr`, `wcspbrk`, `wcsrchr`, `wcsstr`, and
-`wmemchr` have different signatures in this document, but they have the
-same behavior as in the C standard library [[library.c]]. — *end note*]
-See also: ISO C 7.29
-### Header `<cuchar>` synopsis <a id="cuchar.syn">[[cuchar.syn]]</a>
-``` cpp
-namespace std {
-  using mbstate_t = see below;
-  using size_t = see [support.types.layout];
-  size_t mbrtoc8(char8_t* pc8, const char* s, size_t n, mbstate_t* ps);
-  size_t c8rtomb(char* s, char8_t c8, mbstate_t* ps);
-  size_t mbrtoc16(char16_t* pc16, const char* s, size_t n, mbstate_t* ps);
-  size_t c16rtomb(char* s, char16_t c16, mbstate_t* ps);
-  size_t mbrtoc32(char32_t* pc32, const char* s, size_t n, mbstate_t* ps);
-  size_t c32rtomb(char* s, char32_t c32, mbstate_t* ps);
-}
-```
-The contents and meaning of the header `<cuchar>` are the same as the C
-standard library header `<uchar.h>`, except that it declares the
-additional `mbrtoc8` and `c8rtomb` functions and does not declare types
-`char16_t` nor `char32_t`.
-See also: ISO C 7.28
-### Multibyte / wide string and character conversion functions <a id="c.mb.wcs">[[c.mb.wcs]]</a>
-[*Note 1*: The headers `<cstdlib>`, `<cuchar>`, and `<cwchar>` declare
-the functions described in this subclause. — *end note*]
-``` cpp
-int mbsinit(const mbstate_t* ps);
-int mblen(const char* s, size_t n);
-size_t mbstowcs(wchar_t* pwcs, const char* s, size_t n);
-size_t wcstombs(char* s, const wchar_t* pwcs, size_t n);
-```
-*Effects:* These functions have the semantics specified in the C
-standard library.
-See also: ISO C 7.22.7.1, 7.22.8, 7.29.6.2.1
-``` cpp
-int mbtowc(wchar_t* pwc, const char* s, size_t n);
-int wctomb(char* s, wchar_t wchar);
-```
-*Effects:* These functions have the semantics specified in the C
-standard library.
-*Remarks:* Calls to these functions may introduce a data
-race [[res.on.data.races]] with other calls to the same function.
-See also: ISO C 7.22.7
-``` cpp
-size_t mbrlen(const char* s, size_t n, mbstate_t* ps);
-size_t mbrtowc(wchar_t* pwc, const char* s, size_t n, mbstate_t* ps);
-size_t wcrtomb(char* s, wchar_t wc, mbstate_t* ps);
-size_t mbsrtowcs(wchar_t* dst, const char** src, size_t len, mbstate_t* ps);
-size_t wcsrtombs(char* dst, const wchar_t** src, size_t len, mbstate_t* ps);
-```
-*Effects:* These functions have the semantics specified in the C
-standard library.
-*Remarks:* Calling these functions with an `mbstate_t*` argument that is
-a null pointer value may introduce a data race [[res.on.data.races]]
-with other calls to the same function with an `mbstate_t*` argument that
-is a null pointer value.
-See also: ISO C 7.29.6.3
-``` cpp
-size_t mbrtoc8(char8_t* pc8, const char* s, size_t n, mbstate_t* ps);
-```
-*Effects:* If `s` is a null pointer, equivalent to
-`mbrtoc8(nullptr, "", 1, ps)`. Otherwise, the function inspects at most
-`n` bytes beginning with the byte pointed to by `s` to determine the
-number of bytes needed to complete the next multibyte character
-(including any shift sequences). If the function determines that the
-next multibyte character is complete and valid, it determines the values
-of the corresponding UTF-8 code units and then, if `pc8` is not a null
-pointer, stores the value of the first (or only) such code unit in the
-object pointed to by `pc8`. Subsequent calls will store successive UTF-8
-code units without consuming any additional input until all the code
-units have been stored. If the corresponding Unicode character is
-U+0000 (null), the resulting state described is the initial conversion
-state.
-*Returns:* The first of the following that applies (given the current
-conversion state):
-- `0`, if the next `n` or fewer bytes complete the multibyte character
-  that corresponds to the U+0000 (null) Unicode character (which is the
-  value stored).
-- between `1` and `n` (inclusive), if the next n or fewer bytes complete
-  a valid multibyte character (whose first (or only) code unit is
-  stored); the value returned is the number of bytes that complete the
-  multibyte character.
-- `(size_t)(-3)`, if the next code unit resulting from a previous call
-  has been stored (no bytes from the input have been consumed by this
-  call).
-- `(size_t)(-2)`, if the next `n` bytes contribute to an incomplete (but
-  potentially valid) multibyte character, and all `n` bytes have been
-  processed (no value is stored).
-- `(size_t)(-1)`, if an encoding error occurs, in which case the next
-  `n` or fewer bytes do not contribute to a complete and valid multibyte
-  character (no value is stored); the value of the macro `EILSEQ` is
-  stored in `errno`, and the conversion state is unspecified.
-``` cpp
-size_t c8rtomb(char* s, char8_t c8, mbstate_t* ps);
-```
-*Effects:* If `s` is a null pointer, equivalent to
-`c8rtomb(buf, u8’`\`0’, ps)` where `buf` is an internal buffer.
-Otherwise, if `c8` completes a sequence of valid UTF-8 code units,
-determines the number of bytes needed to represent the multibyte
-character (including any shift sequences), and stores the multibyte
-character representation in the array whose first element is pointed to
-by `s`. At most `MB_CUR_MAX` bytes are stored. If the multibyte
-character is a null character, a null byte is stored, preceded by any
-shift sequence needed to restore the initial shift state; the resulting
-state described is the initial conversion state.
-*Returns:* The number of bytes stored in the array object (including any
-shift sequences). If `c8` does not contribute to a sequence of `char8_t`
-corresponding to a valid multibyte character, the value of the macro
-`EILSEQ` is stored in `errno`, `(size_t) (-1)` is returned, and the
-conversion state is unspecified.
-*Remarks:* Calls to `c8rtomb` with a null pointer argument for `s` may
-introduce a data race [[res.on.data.races]] with other calls to
-`c8rtomb` with a null pointer argument for `s`.
 <!-- Link reference definitions -->
 [basic.indet]: basic.md#basic.indet
 [basic.string]: #basic.string
 [basic.string.general]: #basic.string.general
 [basic.string.hash]: #basic.string.hash
 [basic.string.literals]: #basic.string.literals
-[c.mb.wcs]: #c.mb.wcs
 [c.strings]: #c.strings
-[cctype.syn]: #cctype.syn
 [char.traits]: #char.traits
 [char.traits.general]: #char.traits.general
 [char.traits.req]: #char.traits.req
 [char.traits.require]: #char.traits.require
 [char.traits.specializations]: #char.traits.specializations
@@ -4034,21 +3799,19 @@ introduce a data race [[res.on.data.races]] with other calls to
 [char.traits.specializations.char8.t]: #char.traits.specializations.char8.t
 [char.traits.specializations.general]: #char.traits.specializations.general
 [char.traits.specializations.wchar.t]: #char.traits.specializations.wchar.t
 [char.traits.typedefs]: #char.traits.typedefs
 [cmp.categories]: support.md#cmp.categories
 [container.reqmts]: containers.md#container.reqmts
 [container.requirements]: containers.md#container.requirements
-[container.requirements.general]: containers.md#container.requirements.general
 [cpp17.copyassignable]: #cpp17.copyassignable
 [cpp17.copyconstructible]: #cpp17.copyconstructible
 [cpp17.defaultconstructible]: #cpp17.defaultconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cstring.syn]: #cstring.syn
-[cuchar.syn]: #cuchar.syn
-[cwchar.syn]: #cwchar.syn
-[cwctype.syn]: #cwctype.syn
 [defns.character.container]: intro.md#defns.character.container
 [input.output]: input.md#input.output
 [intro.object]: basic.md#intro.object
 [iostream.forward]: input.md#iostream.forward
 [iostreams.limits.pos]: input.md#iostreams.limits.pos
@@ -4058,10 +3821,11 @@ introduce a data race [[res.on.data.races]] with other calls to
 [iterator.concept.winc]: iterators.md#iterator.concept.winc
 [iterator.range]: iterators.md#iterator.range
 [iterator.requirements.general]: iterators.md#iterator.requirements.general
 [library.c]: library.md#library.c
 [ostream.formatted.reqmts]: input.md#ostream.formatted.reqmts
 [random.access.iterators]: iterators.md#random.access.iterators
 [res.on.data.races]: library.md#res.on.data.races
 [sequence.reqmts]: containers.md#sequence.reqmts
 [string.access]: #string.access
 [string.accessors]: #string.accessors
@@ -4098,11 +3862,10 @@ introduce a data race [[res.on.data.races]] with other calls to
 [string.view]: #string.view
 [string.view.access]: #string.view.access
 [string.view.capacity]: #string.view.capacity
 [string.view.compare]: #string.view.compare
 [string.view.comparison]: #string.view.comparison
-[string.view.comparison.overloads]: #string.view.comparison.overloads
 [string.view.cons]: #string.view.cons
 [string.view.deduct]: #string.view.deduct
 [string.view.find]: #string.view.find
 [string.view.general]: #string.view.general
 [string.view.hash]: #string.view.hash

 # Strings library <a id="strings">[[strings]]</a>
 ## General <a id="strings.general">[[strings.general]]</a>
 This Clause describes components for manipulating sequences of any
+non-array trivially copyable standard-layout
+[[term.standard.layout.type]] type `T` where
+`is_trivially_default_constructible_v<T>` is `true`. Such types are
+called *char-like types*, and objects of char-like types are called
+*char-like objects* or simply *characters*.
 The following subclauses describe a character traits class, string
 classes, and null-terminated sequence utilities, as summarized in
 [[strings.summary]].
 values of type `C`; `p` and `q` denote values of type `const C*`; `s`
 denotes a value of type `C*`; `n`, `i` and `j` denote values of type
 `size_t`; `e` and `f` denote values of type `X::int_type`; `pos` denotes
 a value of type `X::pos_type`; and `r` denotes an lvalue of type `C`. No
 expression which is part of the character traits requirements specified
+in [[char.traits.require]] shall exit via an exception.
 The class template
 ``` cpp
 template<class charT> struct char_traits;
 interoperate with these functions. — *end note*]
 ### Header `<string_view>` synopsis <a id="string.view.synop">[[string.view.synop]]</a>
 ``` cpp
+// mostly freestanding
 #include <compare>              // see [compare.syn]
 namespace std {
   // [string.view.template], class template basic_string_view
   template<class charT, class traits = char_traits<charT>>
+  class basic_string_view;                                              // partially freestanding
   template<class charT, class traits>
+    constexpr bool ranges::\libspec{enable_view}{basic_string_view}<basic_string_view<charT, traits>> = true;
   template<class charT, class traits>
+    constexpr bool ranges::\libspec{enable_borrowed_range}{basic_string_view}<basic_string_view<charT, traits>> = true;
   // [string.view.comparison], non-member comparison functions
   template<class charT, class traits>
     constexpr bool operator==(basic_string_view<charT, traits> x,
+ type_identity_t<basic_string_view<charT, traits>> y) noexcept;
   template<class charT, class traits>
     constexpr see below operator<=>(basic_string_view<charT, traits> x,
+              \itcorr                      type_identity_t<basic_string_view<charT,
+              \itcorr                                      traits>> y) noexcept;
   // [string.view.io], inserters and extractors
   template<class charT, class traits>
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& os,
+                 basic_string_view<charT, traits> str);                 // hosted
   // basic_string_view typedef-names
   using string_view    = basic_string_view<char>;
   using u8string_view  = basic_string_view<char8_t>;
   using u16string_view = basic_string_view<char16_t>;
     // [string.view.capacity], capacity
     constexpr size_type size() const noexcept;
     constexpr size_type length() const noexcept;
     constexpr size_type max_size() const noexcept;
+    constexpr bool empty() const noexcept;
     // [string.view.access], element access
     constexpr const_reference operator[](size_type pos) const;
+    constexpr const_reference at(size_type pos) const;                  // freestanding-deleted
     constexpr const_reference front() const;
     constexpr const_reference back() const;
     constexpr const_pointer data() const noexcept;
     // [string.view.modifiers], modifiers
     constexpr void remove_prefix(size_type n);
     constexpr void remove_suffix(size_type n);
     constexpr void swap(basic_string_view& s) noexcept;
     // [string.view.ops], string operations
+    constexpr size_type copy(charT* s, size_type n,
+                             size_type pos = 0) const;                  // freestanding-deleted
+    constexpr basic_string_view substr(size_type pos = 0,
+                                       size_type n = npos) const;       // freestanding-deleted
+    constexpr basic_string_view subview(size_type pos = 0,
+                                        size_type n = npos) const;      // freestanding-deleted
     constexpr int compare(basic_string_view s) const noexcept;
+    constexpr int compare(size_type pos1, size_type n1,
+                          basic_string_view s) const;                   // freestanding-deleted
     constexpr int compare(size_type pos1, size_type n1, basic_string_view s,
+                          size_type pos2, size_type n2) const;          // freestanding-deleted
     constexpr int compare(const charT* s) const;
+    constexpr int compare(size_type pos1, size_type n1,
+ const charT* s) const;                        // freestanding-deleted
+    constexpr int compare(size_type pos1, size_type n1, const charT* s,
+                          size_type n2) const;                          // freestanding-deleted
     constexpr bool starts_with(basic_string_view x) const noexcept;
     constexpr bool starts_with(charT x) const noexcept;
     constexpr bool starts_with(const charT* x) const;
     constexpr bool ends_with(basic_string_view x) const noexcept;
 For a `basic_string_view str`, any operation that invalidates a pointer
 in the range
 ``` cpp
+{[}str.data(), str.data() + str.size(){)}
 ```
+invalidates pointers, iterators, and references to elements of `str`.
 The complexity of `basic_string_view` member functions is 𝑂(1) unless
 otherwise specified.
 `basic_string_view<charT, traits>` is a trivially copyable type
 ``` cpp
 constexpr basic_string_view() noexcept;
 ```
+*Ensures:* *`size_`*` == 0` and *`data_`*` == nullptr`.
 ``` cpp
 constexpr basic_string_view(const charT* str);
 ```
 *Preconditions:* \[`str`, `str + traits::length(str)`) is a valid range.
+*Effects:* Constructs a `basic_string_view`, initializing *data\_* with
+`str` and initializing *size\_* with `traits::length(str)`.
 *Complexity:* 𝑂(`traits::length(str)`).
 ``` cpp
 constexpr basic_string_view(const charT* str, size_type len);
 ```
 *Preconditions:* \[`str`, `str + len`) is a valid range.
+*Effects:* Constructs a `basic_string_view`, initializing *data\_* with
+`str` and initializing *size\_* with `len`.
 ``` cpp
 template<class It, class End>
   constexpr basic_string_view(It begin, End end);
 ```
 - \[`begin`, `end`) is a valid range.
 - `It` models `contiguous_iterator`.
 - `End` models `sized_sentinel_for<It>`.
+*Effects:* Initializes *data\_* with `to_address(begin)` and initializes
+*size\_* with `end - begin`.
 *Throws:* When and what `end - begin` throws.
 ``` cpp
 template<class R>
 - `is_same_v<ranges::range_value_t<R>, charT>` is `true`,
 - `is_convertible_v<R, const charT*>` is `false`, and
 - `d.operator ::std::basic_string_view<charT, traits>()` is not a valid
   expression.
+*Effects:* Initializes *data\_* with `ranges::data(r)` and *size\_* with
 `ranges::size(r)`.
 *Throws:* Any exception thrown by `ranges::data(r)` and
 `ranges::size(r)`.
 constexpr const_iterator cbegin() const noexcept;
 ```
 *Returns:* An iterator such that
+- if `!empty()`, `addressof(*begin()) == `*`data_`*,
 - otherwise, an unspecified value such that \[`begin()`, `end()`) is a
   valid range.
 ``` cpp
 constexpr const_iterator end() const noexcept;
 ``` cpp
 constexpr size_type size() const noexcept;
 constexpr size_type length() const noexcept;
 ```
+*Returns:* *size\_*.
 ``` cpp
 constexpr size_type max_size() const noexcept;
 ```
 *Returns:* The largest possible number of char-like objects that can be
 referred to by a `basic_string_view`.
 ``` cpp
+constexpr bool empty() const noexcept;
 ```
+*Returns:* *`size_`*` == 0`.
 #### Element access <a id="string.view.access">[[string.view.access]]</a>
 ``` cpp
 constexpr const_reference operator[](size_type pos) const;
 ```
+`pos < size()` is `true`.
+[*Note 1*: This precondition is stronger than the one on
+`basic_string::operator[]`. — *end note*]
+*Returns:* *`data_`*`[pos]`.
 *Throws:* Nothing.
 ``` cpp
 constexpr const_reference at(size_type pos) const;
 ```
+*Returns:* *`data_`*`[pos]`.
 *Throws:* `out_of_range` if `pos >= size()`.
 ``` cpp
 constexpr const_reference front() const;
 ```
+`empty()` is `false`.
+*Returns:* *`data_`*`[0]`.
 *Throws:* Nothing.
 ``` cpp
 constexpr const_reference back() const;
 ```
+`empty()` is `false`.
+*Returns:* *`data_`*`[size() - 1]`.
 *Throws:* Nothing.
 ``` cpp
 constexpr const_pointer data() const noexcept;
 ```
+*Returns:* *data\_*.
 [*Note 2*: Unlike `basic_string::data()` and *string-literal*s,
 `data()` can return a pointer to a buffer that is not null-terminated.
 Therefore it is typically a mistake to pass `data()` to a function that
 takes just a `const charT*` and expects a null-terminated
 ``` cpp
 constexpr void remove_prefix(size_type n);
 ```
+`n <= size()` is `true`.
+*Effects:* Equivalent to: *`data_`*` += n; `*`size_`*` -= n;`
 ``` cpp
 constexpr void remove_suffix(size_type n);
 ```
+`n <= size()` is `true`.
+*Effects:* Equivalent to: *`size_`*` -= n;`
 ``` cpp
 constexpr void swap(basic_string_view& s) noexcept;
 ```
 *Complexity:* 𝑂(`rlen`).
 ``` cpp
 constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
+constexpr basic_string_view subview(size_type pos = 0, size_type n = npos) const;
 ```
 Let `rlen` be the smaller of `n` and `size() - pos`.
 *Effects:* Determines `rlen`, the effective length of the string to
 ``` cpp
 constexpr bool starts_with(basic_string_view x) const noexcept;
 ```
+Let `rlen` be the smaller of `size()` and `x.size()`.
+*Effects:* Equivalent to: `return basic_string_view(data(), rlen) == x;`
 ``` cpp
 constexpr bool starts_with(charT x) const noexcept;
 ```
 ``` cpp
 constexpr bool ends_with(basic_string_view x) const noexcept;
 ```
+Let `rlen` be the smaller of `size()` and `x.size()`.
 *Effects:* Equivalent to:
 ``` cpp
+return basic_string_view(data() + (size() - rlen), rlen) == x;
 ```
 ``` cpp
 constexpr bool ends_with(charT x) const noexcept;
 ```
 Let `xpos` be the lowest position, if possible, such that the following
 conditions hold:
 - `pos <= xpos`
 - `xpos + str.size() <= size()`
+- `traits::eq(`*`data_`*`[xpos + I], str[I])` for all elements `I` of
+ the string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
 Let `xpos` be the highest position, if possible, such that the following
 conditions hold:
 - `xpos <= pos`
 - `xpos + str.size() <= size()`
+- `traits::eq(`*`data_`*`[xpos + I], str[I])` for all elements `I` of
+ the string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
 Let `xpos` be the lowest position, if possible, such that the following
 conditions hold:
 - `pos <= xpos`
 - `xpos < size()`
+- `traits::eq(`*`data_`*`[xpos], str[I])` for some element `I` of the
+ string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
 Let `xpos` be the highest position, if possible, such that the following
 conditions hold:
 - `xpos <= pos`
 - `xpos < size()`
+- `traits::eq(`*`data_`*`[xpos], str[I])` for some element `I` of the
+ string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
 Let `xpos` be the lowest position, if possible, such that the following
 conditions hold:
 - `pos <= xpos`
 - `xpos < size()`
+- `traits::eq(`*`data_`*`[xpos], str[I])` for no element `I` of the
+ string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
 Let `xpos` be the highest position, if possible, such that the following
 conditions hold:
 - `xpos <= pos`
 - `xpos < size()`
+- `traits::eq(`*`data_`*`[xpos], str[I])` for no element `I` of the
+ string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
 ### Non-member comparison functions <a id="string.view.comparison">[[string.view.comparison]]</a>
 ``` cpp
 template<class charT, class traits>
   constexpr bool operator==(basic_string_view<charT, traits> lhs,
+ type_identity_t<basic_string_view<charT, traits>> rhs) noexcept;
 ```
 *Returns:* `lhs.compare(rhs) == 0`.
 ``` cpp
 template<class charT, class traits>
   constexpr see below operator<=>(basic_string_view<charT, traits> lhs,
+            \itcorr                      type_identity_t<basic_string_view<charT, traits>> rhs) noexcept;
 ```
 Let `R` denote the type `traits::comparison_category` if that
 *qualified-id* is valid and denotes a type [[temp.deduct]], otherwise
 `R` is `weak_ordering`.
 *Mandates:* `R` denotes a comparison category type [[cmp.categories]].
 *Returns:* `static_cast<R>(lhs.compare(rhs) <=> 0)`.
+[*Note 1*: The usage of `type_identity_t` as parameter ensures that an
+object of type `basic_string_view<charT, traits>` can always be compared
+with an object of a type `T` with an implicit conversion to
+`basic_string_view<charT, traits>`, and vice versa, as per
+[[over.match.oper]]. — *end note*]
 ### Inserters and extractors <a id="string.view.io">[[string.view.io]]</a>
 ``` cpp
 template<class charT, class traits>
   basic_ostream<charT, traits>&
 range \[`str.begin()`, `str.end()`). Determines padding for `seq` as
 described in  [[ostream.formatted.reqmts]]. Then inserts `seq` as if by
 calling `os.rdbuf()->sputn(seq, n)`, where `n` is the larger of
 `os.width()` and `str.size()`; then calls `os.width(0)`.
+*Returns:* `os`.
 ### Hash support <a id="string.view.hash">[[string.view.hash]]</a>
 ``` cpp
 template<> struct hash<string_view>;
 #include <compare>              // see [compare.syn]
 #include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   // [char.traits], character traits
+  template<class charT> struct char_traits;                             // freestanding
+  template<> struct char_traits<char>;                                  // freestanding
+  template<> struct char_traits<char8_t>;                               // freestanding
+  template<> struct char_traits<char16_t>;                              // freestanding
+  template<> struct char_traits<char32_t>;                              // freestanding
+  template<> struct char_traits<wchar_t>;                               // freestanding
   // [basic.string], basic_string
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_string;
                 charT rhs);
   template<class charT, class traits, class Allocator>
     constexpr basic_string<charT, traits, Allocator>
       operator+(basic_string<charT, traits, Allocator>&& lhs,
                 charT rhs);
+  template<class charT, class traits, class Allocator>
+    constexpr basic_string<charT, traits, Allocator>
+      operator+(const basic_string<charT, traits, Allocator>& lhs,
+                type_identity_t<basic_string_view<charT, traits>> rhs);
+  template<class charT, class traits, class Allocator>
+    constexpr basic_string<charT, traits, Allocator>
+      operator+(basic_string<charT, traits, Allocator>&& lhs,
+                type_identity_t<basic_string_view<charT, traits>> rhs);
+  template<class charT, class traits, class Allocator>
+    constexpr basic_string<charT, traits, Allocator>
+      operator+(type_identity_t<basic_string_view<charT, traits>> lhs,
+                const basic_string<charT, traits, Allocator>& rhs);
+  template<class charT, class traits, class Allocator>
+    constexpr basic_string<charT, traits, Allocator>
+      operator+(type_identity_t<basic_string_view<charT, traits>> lhs,
+                basic_string<charT, traits, Allocator>&& rhs);
   template<class charT, class traits, class Allocator>
     constexpr bool
       operator==(const basic_string<charT, traits, Allocator>& lhs,
                  const basic_string<charT, traits, Allocator>& rhs) noexcept;
     basic_istream<charT, traits>&
       getline(basic_istream<charT, traits>&& is,
               basic_string<charT, traits, Allocator>& str);
   // [string.erasure], erasure
+  template<class charT, class traits, class Allocator, class U = charT>
     constexpr typename basic_string<charT, traits, Allocator>::size_type
       erase(basic_string<charT, traits, Allocator>& c, const U& value);
   template<class charT, class traits, class Allocator, class Predicate>
     constexpr typename basic_string<charT, traits, Allocator>::size_type
       erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred);
   public:
     // types
     using traits_type            = traits;
     using value_type             = charT;
     using allocator_type         = Allocator;
+    using size_type              = allocator_traits<Allocator>::size_type;
+    using difference_type        = allocator_traits<Allocator>::difference_type;
+    using pointer                = allocator_traits<Allocator>::pointer;
+    using const_pointer          = allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using iterator               = implementation-defined  // type of basic_string::iterator; // see [container.requirements]
     using const_iterator         = implementation-defined  // type of basic_string::const_iterator; // see [container.requirements]
     template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
     constexpr size_type capacity() const noexcept;
     constexpr void reserve(size_type res_arg);
     constexpr void shrink_to_fit();
     constexpr void clear() noexcept;
+    constexpr bool empty() const noexcept;
     // [string.access], element access
     constexpr const_reference operator[](size_type pos) const;
     constexpr reference       operator[](size_type pos);
     constexpr const_reference at(size_type n) const;
     constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
     constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
     constexpr basic_string substr(size_type pos = 0, size_type n = npos) const &;
     constexpr basic_string substr(size_type pos = 0, size_type n = npos) &&;
+    constexpr basic_string_view<charT, traits> subview(size_type pos = 0,
+                                                       size_type n = npos) const;
     template<class T>
       constexpr int compare(const T& t) const noexcept(see below);
     template<class T>
       constexpr int compare(size_type pos1, size_type n1, const T& t) const;
 If any member function or operator of `basic_string` throws an
 exception, that function or operator has no other effect on the
 `basic_string` object.
+Every object of type `basic_string<charT, traits, Allocator>` uses an
+object of type `Allocator` to allocate and free storage for the
+contained `charT` objects as needed. The `Allocator` object used is
+obtained as described in [[container.reqmts]]. In every specialization
 `basic_string<charT, traits, Allocator>`, the type `traits` shall meet
 the character traits requirements [[char.traits]].
 [*Note 1*: Every specialization
+`basic_string<charT, traits, Allocator>` is an allocator-aware container
+[[container.alloc.reqmts]], but does not use the allocator’s `construct`
+and `destroy` member functions [[container.requirements.pre]]. The
+program is ill-formed if `Allocator::value_type` is not the same type as
+`charT`. — *end note*]
 [*Note 2*: The program is ill-formed if `traits::char_type` is not the
 same type as `charT`. — *end note*]
 References, pointers, and iterators referring to the elements of a
 ``` cpp
 constexpr basic_string(const charT* s, const Allocator& a = Allocator());
 ```
 *Constraints:* `Allocator` is a type that qualifies as an
+allocator [[container.reqmts]].
 [*Note 1*: This affects class template argument
 deduction. — *end note*]
 *Effects:* Equivalent to: `basic_string(s, traits::length(s), a)`.
 ``` cpp
 constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
 ```
 *Constraints:* `Allocator` is a type that qualifies as an
+allocator [[container.reqmts]].
 [*Note 2*: This affects class template argument
 deduction. — *end note*]
 *Effects:* Constructs an object whose value consists of `n` copies of
 template<class InputIterator>
   constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
 ```
 *Constraints:* `InputIterator` is a type that qualifies as an input
+iterator [[container.reqmts]].
 *Effects:* Constructs a string from the values in the range \[`begin`,
 `end`), as specified in [[sequence.reqmts]].
 ``` cpp
                     Allocator>;
 ```
 *Constraints:* `InputIterator` is a type that qualifies as an input
 iterator, and `Allocator` is a type that qualifies as an
+allocator [[container.reqmts]].
 ``` cpp
 template<class charT,
          class traits,
          class Allocator = allocator<charT>>
                const Allocator& = Allocator())
     -> basic_string<charT, traits, Allocator>;
 ```
 *Constraints:* `Allocator` is a type that qualifies as an
+allocator [[container.reqmts]].
 ``` cpp
 constexpr basic_string& operator=(const basic_string& str);
 ```
 constexpr basic_string& operator=(basic_string&& str)
   noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
+*Effects:* Move assigns as a sequence container [[sequence.reqmts]],
+except that iterators, pointers and references may be invalidated.
 *Returns:* `*this`.
 ``` cpp
 template<class T>
 constexpr void reserve(size_type res_arg);
 ```
 *Effects:* A directive that informs a `basic_string` of a planned change
 in size, so that the storage allocation can be managed accordingly.
+Following a call to `reserve`, `capacity()` is greater or equal to the
+argument of `reserve` if reallocation happens; and equal to the previous
+value of `capacity()` otherwise. Reallocation happens at this point if
+and only if the current capacity is less than the argument of `reserve`.
 *Throws:* `length_error` if `res_arg > max_size()` or any exceptions
 thrown by `allocator_traits` `<Allocator>::allocate`.
 ``` cpp
 ```
 *Effects:* Equivalent to: `erase(begin(), end());`
 ``` cpp
+constexpr bool empty() const noexcept;
 ```
 *Effects:* Equivalent to: `return size() == 0;`
 #### Element access <a id="string.access">[[string.access]]</a>
 ``` cpp
 constexpr const_reference operator[](size_type pos) const;
 constexpr reference       operator[](size_type pos);
 ```
+`pos <= size()` is `true`.
 *Returns:* `*(begin() + pos)` if `pos < size()`. Otherwise, returns a
 reference to an object of type `charT` with value `charT()`, where
 modifying the object to any value other than `charT()` leads to
 undefined behavior.
 ``` cpp
 constexpr const charT& front() const;
 constexpr charT& front();
 ```
+`empty()` is `false`.
 *Effects:* Equivalent to: `return operator[](0);`
 ``` cpp
 constexpr const charT& back() const;
 constexpr charT& back();
 ```
+`empty()` is `false`.
 *Effects:* Equivalent to: `return operator[](size() - 1);`
 #### Modifiers <a id="string.modifiers">[[string.modifiers]]</a>
 template<class InputIterator>
   constexpr basic_string& append(InputIterator first, InputIterator last);
 ```
 *Constraints:* `InputIterator` is a type that qualifies as an input
+iterator [[container.reqmts]].
 *Effects:* Equivalent to:
 `return append(basic_string(first, last, get_allocator()));`
 ``` cpp
 template<class InputIterator>
   constexpr basic_string& assign(InputIterator first, InputIterator last);
 ```
 *Constraints:* `InputIterator` is a type that qualifies as an input
+iterator [[container.reqmts]].
 *Effects:* Equivalent to:
 `return assign(basic_string(first, last, get_allocator()));`
 ``` cpp
 ```
 *Effects:* Inserts `n` copies of `c` before the character at position
 `pos` if `pos < size()`, or otherwise at the end of the string.
+*Returns:* `*this`.
 *Throws:*
 - `out_of_range` if `pos > size()`,
 - `length_error` if `n > max_size() - size()`, or
 template<class InputIterator>
   constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
 ```
 *Constraints:* `InputIterator` is a type that qualifies as an input
+iterator [[container.reqmts]].
 *Preconditions:* `p` is a valid iterator on `*this`.
 *Effects:* Equivalent to
 `insert(p - begin(), basic_string(first, last, get_allocator()))`.
 ```
 *Preconditions:* `first` and `last` are valid iterators on `*this`.
 \[`first`, `last`) is a valid range.
+*Effects:* Removes the characters in the range \[`first`, `last`).
 *Returns:* An iterator which points to the element pointed to by `last`
 prior to the other elements being erased. If no such element exists,
 `end()` is returned.
 ``` cpp
 constexpr void pop_back();
 ```
+`empty()` is `false`.
 *Effects:* Equivalent to `erase(end() - 1)`.
 *Throws:* Nothing.
 *Returns:* `*this`.
 *Throws:*
 - `out_of_range` if `pos1 > size()`,
+- `length_error` if the length of the resulting string would exceed
+  `max_size()`, or
 - any exceptions thrown by `allocator_traits<Allocator>::allocate.`
 ``` cpp
 constexpr basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
 ```
   constexpr basic_string& replace(const_iterator i1, const_iterator i2,
                                   InputIterator j1, InputIterator j2);
 ```
 *Constraints:* `InputIterator` is a type that qualifies as an input
+iterator [[container.reqmts]].
 *Effects:* Equivalent to:
 `return replace(i1, i2, basic_string(j1, j2, get_allocator()));`
 ``` cpp
 ```
 *Effects:* Equivalent to:
 `return basic_string(std::move(*this), pos, n);`
+``` cpp
+constexpr basic_string_view<charT, traits> subview(size_type pos = 0, size_type n = npos) const;
+```
+*Effects:* Equivalent to:
+`return basic_string_view<charT, traits>(*this).subview(pos, n);`
 ##### `basic_string::compare` <a id="string.compare">[[string.compare]]</a>
 ``` cpp
 template<class T>
   constexpr int compare(const T& t) const noexcept(see below);
 ``` cpp
 lhs.push_back(rhs);
 return std::move(lhs);
 ```
+``` cpp
+template<class charT, class traits, class Allocator>
+  constexpr basic_string<charT, traits, Allocator>
+    operator+(const basic_string<charT, traits, Allocator>& lhs,
+              type_identity_t<basic_string_view<charT, traits>> rhs);
+```
+Equivalent to:
+``` cpp
+basic_string<charT, traits, Allocator> r = lhs;
+r.append(rhs);
+return r;
+```
+``` cpp
+template<class charT, class traits, class Allocator>
+  constexpr basic_string<charT, traits, Allocator>
+    operator+(basic_string<charT, traits, Allocator>&& lhs,
+              type_identity_t<basic_string_view<charT, traits>> rhs);
+```
+Equivalent to:
+``` cpp
+lhs.append(rhs);
+return std::move(lhs);
+```
+``` cpp
+template<class charT, class traits, class Allocator>
+  constexpr basic_string<charT, traits, Allocator>
+    operator+(type_identity_t<basic_string_view<charT, traits>> lhs,
+              const basic_string<charT, traits, Allocator>& rhs);
+```
+Equivalent to:
+``` cpp
+basic_string<charT, traits, Allocator> r = rhs;
+r.insert(0, lhs);
+return r;
+```
+``` cpp
+template<class charT, class traits, class Allocator>
+  constexpr basic_string<charT, traits, Allocator>
+    operator+(type_identity_t<basic_string_view<charT, traits>> lhs,
+              basic_string<charT, traits, Allocator>&& rhs);
+```
+Equivalent to:
+``` cpp
+rhs.insert(0, lhs);
+return std::move(rhs);
+```
+[*Note 1*: Using a specialization of `type_identity_t` as a parameter
+type ensures that an object of type
+`basic_string<charT, traits, Allocator>` can be concatenated with an
+object of a type `T` having an implicit conversion to
+`basic_string_view<charT, traits>` [[over.match.oper]]. — *end note*]
 #### Non-member comparison operator functions <a id="string.cmp">[[string.cmp]]</a>
 ``` cpp
 template<class charT, class traits, class Allocator>
   constexpr bool
 *Returns:* `getline(is, str, is.widen(’\n’))`.
 #### Erasure <a id="string.erasure">[[string.erasure]]</a>
 ``` cpp
+template<class charT, class traits, class Allocator, class U = charT>
   constexpr typename basic_string<charT, traits, Allocator>::size_type
     erase(basic_string<charT, traits, Allocator>& c, const U& value);
 ```
 *Effects:* Equivalent to:
 string to_string(float val);
 string to_string(double val);
 string to_string(long double val);
 ```
+*Returns:* `format("{}", val)`.
 ``` cpp
 int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);
 long stol(const wstring& str, size_t* idx = nullptr, int base = 10);
 unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);
 wstring to_wstring(float val);
 wstring to_wstring(double val);
 wstring to_wstring(long double val);
 ```
+*Returns:* `format(L"{}", val)`.
 ### Hash support <a id="basic.string.hash">[[basic.string.hash]]</a>
 ``` cpp
 template<class A> struct hash<basic_string<char, char_traits<char>, A>>;
 to numbers and string literal suffixes apply to character array
 literals. — *end note*]
 ## Null-terminated sequence utilities <a id="c.strings">[[c.strings]]</a>
 ### Header `<cstring>` synopsis <a id="cstring.syn">[[cstring.syn]]</a>
 ``` cpp
+#define __STDC_VERSION_STRING_H__ 202311L
 namespace std {
+  using size_t = see [support.types.layout];                                            // freestanding
+  void* memcpy(void* s1, const void* s2, size_t n);                     // freestanding
+  void* memccpy(void* s1, const void* s2, int c, size_t n);             // freestanding
+ void* memmove(void* s1, const void* s2, size_t n);                    // freestanding
+  char* strcpy(char* s1, const char* s2);                               // freestanding
+  char* strncpy(char* s1, const char* s2, size_t n);                    // freestanding
+  char* strdup(const char* s);
+ char* strndup(const char* s, size_t size);
+ char* strcat(char* s1, const char* s2);                               // freestanding
+  char* strncat(char* s1, const char* s2, size_t n);                    // freestanding
+  int memcmp(const void* s1, const void* s2, size_t n);                 // freestanding
+  int strcmp(const char* s1, const char* s2);                           // freestanding
   int strcoll(const char* s1, const char* s2);
+  int strncmp(const char* s1, const char* s2, size_t n);                // freestanding
   size_t strxfrm(char* s1, const char* s2, size_t n);
+  const void* memchr(const void* s, int c, size_t n); // freestanding; see [library.c]
+  void* memchr(void* s, int c, size_t n); // freestanding; see [library.c]
+  const char* strchr(const char* s, int c); // freestanding; see [library.c]
+  char* strchr(char* s, int c); // freestanding; see [library.c]
+  size_t strcspn(const char* s1, const char* s2);                       // freestanding
+  const char* strpbrk(const char* s1, const char* s2); // freestanding; see [library.c]
+  char* strpbrk(char* s1, const char* s2); // freestanding; see [library.c]
+  const char* strrchr(const char* s, int c); // freestanding; see [library.c]
+  char* strrchr(char* s, int c); // freestanding; see [library.c]
+  size_t strspn(const char* s1, const char* s2);                        // freestanding
+  const char* strstr(const char* s1, const char* s2); // freestanding; see [library.c]
+  char* strstr(char* s1, const char* s2); // freestanding; see [library.c]
   char* strtok(char* s1, const char* s2);
+  void* memset(void* s, int c, size_t n);                               // freestanding
+  void* memset_explicit(void* s, int c, size_t n);                      // freestanding
   char* strerror(int errnum);
+  size_t strlen(const char* s);                                         // freestanding
 }
+#define NULL see [support.types.nullptr]                                                // freestanding
 ```
 The contents and meaning of the header `<cstring>` are the same as the C
 standard library header `<string.h>`.
 The functions `strerror` and `strtok` are not required to avoid data
 races [[res.on.data.races]].
 The functions `memcpy` and `memmove` are signal-safe [[support.signal]].
+Each of these functions implicitly creates objects [[intro.object]] in
+the destination region of storage immediately prior to copying the
+sequence of characters to the destination. Each of these functions
+returns a pointer to a suitable created object, if any, otherwise the
+value of the first parameter.
 [*Note 1*: The functions `strchr`, `strpbrk`, `strrchr`, `strstr`, and
 `memchr`, have different signatures in this document, but they have the
 same behavior as in the C standard library [[library.c]]. — *end note*]
+See also: ISO C 7.26
 <!-- Link reference definitions -->
 [basic.indet]: basic.md#basic.indet
 [basic.string]: #basic.string
 [basic.string.general]: #basic.string.general
 [basic.string.hash]: #basic.string.hash
 [basic.string.literals]: #basic.string.literals
 [c.strings]: #c.strings
 [char.traits]: #char.traits
 [char.traits.general]: #char.traits.general
 [char.traits.req]: #char.traits.req
 [char.traits.require]: #char.traits.require
 [char.traits.specializations]: #char.traits.specializations
 [char.traits.specializations.char8.t]: #char.traits.specializations.char8.t
 [char.traits.specializations.general]: #char.traits.specializations.general
 [char.traits.specializations.wchar.t]: #char.traits.specializations.wchar.t
 [char.traits.typedefs]: #char.traits.typedefs
 [cmp.categories]: support.md#cmp.categories
+[container.alloc.reqmts]: containers.md#container.alloc.reqmts
 [container.reqmts]: containers.md#container.reqmts
 [container.requirements]: containers.md#container.requirements
+[container.requirements.pre]: containers.md#container.requirements.pre
 [cpp17.copyassignable]: #cpp17.copyassignable
 [cpp17.copyconstructible]: #cpp17.copyconstructible
 [cpp17.defaultconstructible]: #cpp17.defaultconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cstring.syn]: #cstring.syn
 [defns.character.container]: intro.md#defns.character.container
 [input.output]: input.md#input.output
 [intro.object]: basic.md#intro.object
 [iostream.forward]: input.md#iostream.forward
 [iostreams.limits.pos]: input.md#iostreams.limits.pos
 [iterator.concept.winc]: iterators.md#iterator.concept.winc
 [iterator.range]: iterators.md#iterator.range
 [iterator.requirements.general]: iterators.md#iterator.requirements.general
 [library.c]: library.md#library.c
 [ostream.formatted.reqmts]: input.md#ostream.formatted.reqmts
+[over.match.oper]: over.md#over.match.oper
 [random.access.iterators]: iterators.md#random.access.iterators
 [res.on.data.races]: library.md#res.on.data.races
 [sequence.reqmts]: containers.md#sequence.reqmts
 [string.access]: #string.access
 [string.accessors]: #string.accessors
 [string.view]: #string.view
 [string.view.access]: #string.view.access
 [string.view.capacity]: #string.view.capacity
 [string.view.compare]: #string.view.compare
 [string.view.comparison]: #string.view.comparison
 [string.view.cons]: #string.view.cons
 [string.view.deduct]: #string.view.deduct
 [string.view.find]: #string.view.find
 [string.view.general]: #string.view.general
 [string.view.hash]: #string.view.hash

Diff to HTML by rtfpessoa