[basic.string] - C++17 → C++20

Files changed (1) hide show

tmp/tmpwiz1y7ow/{from.md → to.md} +814 -1051

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

@@ -6,34 +6,24 @@ with the first element of the sequence at position zero. Such a sequence
 is also called a “string” if the type of the char-like objects that it
 holds is clear from context. In the rest of this Clause, the type of the
 char-like objects held in a `basic_string` object is designated by
 `charT`.
-The member functions of `basic_string` use an object of the `Allocator`
-class passed as a template parameter to allocate and free storage for
-the contained char-like objects.[^2]
-A `basic_string` is a contiguous container (
-[[container.requirements.general]]).
-In all cases, `size() <= capacity()`.
-The functions described in this Clause can report two kinds of errors,
-each associated with an exception type:
-- a *length* error is associated with exceptions of type
-  `length_error` ([[length.error]]);
-- an *out-of-range* error is associated with exceptions of type
-  `out_of_range` ([[out.of.range]]).
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
   class basic_string {
   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;
@@ -47,479 +37,434 @@ namespace std {
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     static const size_type npos  = -1;
     // [string.cons], construct/copy/destroy
-    basic_string() noexcept(noexcept(Allocator())) : basic_string(Allocator()) { }
-    explicit basic_string(const Allocator& a) noexcept;
-    basic_string(const basic_string& str);
-    basic_string(basic_string&& str) noexcept;
-    basic_string(const basic_string& str, size_type pos,
                            const Allocator& a = Allocator());
-    basic_string(const basic_string& str, size_type pos, size_type n,
                            const Allocator& a = Allocator());
     template<class T>
-      basic_string(const T& t, size_type pos, size_type n,
                              const Allocator& a = Allocator());
- explicit basic_string(basic_string_view<charT, traits> sv,
- const Allocator& a = Allocator());
-    basic_string(const charT* s,
-                 size_type n, const Allocator& a = Allocator());
-    basic_string(const charT* s, const Allocator& a = Allocator());
-    basic_string(size_type n, charT c, const Allocator& a = Allocator());
     template<class InputIterator>
-      basic_string(InputIterator begin, InputIterator end,
                              const Allocator& a = Allocator());
-    basic_string(initializer_list<charT>, const Allocator& = Allocator());
-    basic_string(const basic_string&, const Allocator&);
-    basic_string(basic_string&&, const Allocator&);
- ~basic_string();
-    basic_string& operator=(const basic_string& str);
-    basic_string& operator=(basic_string&& str)
       noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
                allocator_traits<Allocator>::is_always_equal::value);
- basic_string& operator=(basic_string_view<charT, traits> sv);
- basic_string& operator=(const charT* s);
-    basic_string& operator=(charT c);
-    basic_string& operator=(initializer_list<charT>);
     // [string.iterators], iterators
-    iterator       begin() noexcept;
-    const_iterator begin() const noexcept;
-    iterator       end() noexcept;
-    const_iterator end() const noexcept;
-    reverse_iterator       rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator       rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
-    const_iterator         cbegin() const noexcept;
-    const_iterator         cend() const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
     // [string.capacity], capacity
-    size_type size() const noexcept;
-    size_type length() const noexcept;
-    size_type max_size() const noexcept;
-    void resize(size_type n, charT c);
-    void resize(size_type n);
-    size_type capacity() const noexcept;
-    void reserve(size_type res_arg = 0);
-    void shrink_to_fit();
-    void clear() noexcept;
-    bool empty() const noexcept;
     // [string.access], element access
-    const_reference operator[](size_type pos) const;
-    reference       operator[](size_type pos);
-    const_reference at(size_type n) const;
-    reference       at(size_type n);
-    const charT& front() const;
-    charT&       front();
-    const charT& back() const;
-    charT&       back();
     // [string.modifiers], modifiers
-    basic_string& operator+=(const basic_string& str);
-    basic_string& operator+=(basic_string_view<charT, traits> sv);
-    basic_string& operator+=(const charT* s);
-    basic_string& operator+=(charT c);
-    basic_string& operator+=(initializer_list<charT>);
-    basic_string& append(const basic_string& str);
-    basic_string& append(const basic_string& str, size_type pos,
-                         size_type n = npos);
-    basic_string& append(basic_string_view<charT, traits> sv);
     template<class T>
-      basic_string& append(const T& t, size_type pos, size_type n = npos);
-    basic_string& append(const charT* s, size_type n);
-    basic_string& append(const charT* s);
-    basic_string& append(size_type n, charT c);
     template<class InputIterator>
-      basic_string& append(InputIterator first, InputIterator last);
-    basic_string& append(initializer_list<charT>);
-    void push_back(charT c);
- basic_string& assign(const basic_string& str);
-    basic_string& assign(basic_string&& str)
       noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
                allocator_traits<Allocator>::is_always_equal::value);
-    basic_string& assign(const basic_string& str, size_type pos,
-                         size_type n = npos);
-    basic_string& assign(basic_string_view<charT, traits> sv);
     template<class T>
-      basic_string& assign(const T& t, size_type pos, size_type n = npos);
- basic_string& assign(const charT* s, size_type n);
- basic_string& assign(const charT* s);
-    basic_string& assign(size_type n, charT c);
     template<class InputIterator>
-      basic_string& assign(InputIterator first, InputIterator last);
-    basic_string& assign(initializer_list<charT>);
-    basic_string& insert(size_type pos, const basic_string& str);
-    basic_string& insert(size_type pos1, const basic_string& str,
                                    size_type pos2, size_type n = npos);
-    basic_string& insert(size_type pos, basic_string_view<charT, traits> sv);
     template<class T>
-      basic_string& insert(size_type pos1, const T& t,
                                      size_type pos2, size_type n = npos);
-    basic_string& insert(size_type pos, const charT* s, size_type n);
-    basic_string& insert(size_type pos, const charT* s);
-    basic_string& insert(size_type pos, size_type n, charT c);
-    iterator insert(const_iterator p, charT c);
-    iterator insert(const_iterator p, size_type n, charT c);
     template<class InputIterator>
-      iterator insert(const_iterator p, InputIterator first, InputIterator last);
-    iterator insert(const_iterator p, initializer_list<charT>);
-    basic_string& erase(size_type pos = 0, size_type n = npos);
-    iterator erase(const_iterator p);
-    iterator erase(const_iterator first, const_iterator last);
-    void pop_back();
-    basic_string& replace(size_type pos1, size_type n1,
- const basic_string& str);
-    basic_string& replace(size_type pos1, size_type n1,
-                          const basic_string& str,
                                     size_type pos2, size_type n2 = npos);
-    basic_string& replace(size_type pos1, size_type n1,
-                          basic_string_view<charT, traits> sv);
     template<class T>
-      basic_string& replace(size_type pos1, size_type n1, const T& t,
                                       size_type pos2, size_type n2 = npos);
-    basic_string& replace(size_type pos, size_type n1, const charT* s,
- size_type n2);
-    basic_string& replace(size_type pos, size_type n1, const charT* s);
-    basic_string& replace(size_type pos, size_type n1, size_type n2,
-                          charT c);
-    basic_string& replace(const_iterator i1, const_iterator i2,
                                     const basic_string& str);
- basic_string& replace(const_iterator i1, const_iterator i2,
-                          basic_string_view<charT, traits> sv);
-    basic_string& replace(const_iterator i1, const_iterator i2, const charT* s,
                                     size_type n);
-    basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
-    basic_string& replace(const_iterator i1, const_iterator i2,
-                          size_type n, charT c);
     template<class InputIterator>
-      basic_string& replace(const_iterator i1, const_iterator i2,
                                       InputIterator j1, InputIterator j2);
-    basic_string& replace(const_iterator, const_iterator, initializer_list<charT>);
-    size_type copy(charT* s, size_type n, size_type pos = 0) const;
-    void swap(basic_string& str)
       noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
                allocator_traits<Allocator>::is_always_equal::value);
     // [string.ops], string operations
-    const charT* c_str() const noexcept;
-    const charT* data() const noexcept;
-    charT* data() noexcept;
-    operator basic_string_view<charT, traits>() const noexcept;
-    allocator_type get_allocator() const noexcept;
- size_type find (basic_string_view<charT, traits> sv,
- size_type pos = 0) const noexcept;
-    size_type find (const basic_string& str, size_type pos = 0) const noexcept;
-    size_type find (const charT* s, size_type pos, size_type n) const;
-    size_type find (const charT* s, size_type pos = 0) const;
-    size_type find (charT c, size_type pos = 0) const;
- size_type rfind(basic_string_view<charT, traits> sv,
- size_type pos = npos) const noexcept;
-    size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
-    size_type rfind(const charT* s, size_type pos, size_type n) const;
-    size_type rfind(const charT* s, size_type pos = npos) const;
-    size_type rfind(charT c, size_type pos = npos) const;
- size_type find_first_of(basic_string_view<charT, traits> sv,
- size_type pos = 0) const noexcept;
-    size_type find_first_of(const basic_string& str,
- size_type pos = 0) const noexcept;
-    size_type find_first_of(const charT* s,
- size_type pos, size_type n) const;
- size_type find_first_of(const charT* s, size_type pos = 0) const;
- size_type find_first_of(charT c, size_type pos = 0) const;
- size_type find_last_of (basic_string_view<charT, traits> sv,
- size_type pos = npos) const noexcept;
-    size_type find_last_of (const basic_string& str,
                                      size_type pos = npos) const noexcept;
-    size_type find_last_of (const charT* s,
- size_type pos, size_type n) const;
-    size_type find_last_of (const charT* s, size_type pos = npos) const;
-    size_type find_last_of (charT c, size_type pos = npos) const;
- size_type find_first_not_of(basic_string_view<charT, traits> sv,
- size_type pos = 0) const noexcept;
- size_type find_first_not_of(const basic_string& str,
                                           size_type pos = 0) const noexcept;
-    size_type find_first_not_of(const charT* s, size_type pos,
- size_type n) const;
-    size_type find_first_not_of(const charT* s, size_type pos = 0) const;
- size_type find_first_not_of(charT c, size_type pos = 0) const;
- size_type find_last_not_of (basic_string_view<charT, traits> sv,
- size_type pos = npos) const noexcept;
-    size_type find_last_not_of (const basic_string& str,
                                          size_type pos = npos) const noexcept;
-    size_type find_last_not_of (const charT* s, size_type pos,
- size_type n) const;
-    size_type find_last_not_of (const charT* s,
-                                size_type pos = npos) const;
-    size_type find_last_not_of (charT c, size_type pos = npos) const;
-    basic_string substr(size_type pos = 0, size_type n = npos) const;
-    int compare(basic_string_view<charT, traits> sv) const noexcept;
- int compare(size_type pos1, size_type n1,
-                basic_string_view<charT, traits> sv) const;
     template<class T>
-      int compare(size_type pos1, size_type n1, const T& t,
                             size_type pos2, size_type n2 = npos) const;
-    int compare(const basic_string& str) const noexcept;
-    int compare(size_type pos1, size_type n1,
- const basic_string& str) const;
-    int compare(size_type pos1, size_type n1,
-                const basic_string& str,
                           size_type pos2, size_type n2 = npos) const;
-    int compare(const charT* s) const;
-    int compare(size_type pos1, size_type n1,
- const charT* s) const;
-    int compare(size_type pos1, size_type n1,
-                const charT* s, size_type n2) const;
   };
   template<class InputIterator,
            class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
     basic_string(InputIterator, InputIterator, Allocator = Allocator())
       -> basic_string<typename iterator_traits<InputIterator>::value_type,
                       char_traits<typename iterator_traits<InputIterator>::value_type>,
                       Allocator>;
 }
 ```
-#### `basic_string` general requirements <a id="string.require">[[string.require]]</a>
 If any operation would cause `size()` to exceed `max_size()`, that
-operation shall throw an exception object of type `length_error`.
 If any member function or operator of `basic_string` throws an
-exception, that function or operator shall have no other effect.
 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>` shall use an object of type
 `Allocator` to allocate and free storage for the contained `charT`
-objects as needed. The `Allocator` object used shall be obtained as
-described in [[container.requirements.general]]. In every specialization
-`basic_string<charT, traits, Allocator>`, the type `traits` shall
-satisfy the character traits requirements ([[char.traits]]), and the
-type `traits::char_type` shall name the same type as `charT`.
 References, pointers, and iterators referring to the elements of a
 `basic_string` sequence may be invalidated by the following uses of that
 `basic_string` object:
-- as an argument to any standard library function taking a reference to
-  non-const `basic_string` as an argument.[^3]
 - Calling non-const member functions, except `operator[]`, `at`, `data`,
   `front`, `back`, `begin`, `rbegin`, `end`, and `rend`.
-#### `basic_string` constructors and assignment operators <a id="string.cons">[[string.cons]]</a>
 ``` cpp
-explicit basic_string(const Allocator& a) noexcept;
 ```
-*Effects:* Constructs an object of class `basic_string`. The
-postconditions of this function are indicated in
-Table  [[tab:strings.ctr.1]].
-**Table: `basic_string(const Allocator&)` effects** <a id="tab:strings.ctr.1">[tab:strings.ctr.1]</a>
-| Element      | Value                                                          |
-| ------------ | -------------------------------------------------------------- |
-| `data()`     | a non-null pointer that is copyable and can have 0 added to it |
-| `size()`     | 0                                                              |
-| `capacity()` | an unspecified value                                           |
 ``` cpp
-basic_string(const basic_string& str);
-basic_string(basic_string&& str) noexcept;
 ```
-*Effects:* Constructs an object of class `basic_string` as indicated in
-Table  [[tab:strings.ctr.cpy]]. In the second form, `str` is left in a
-valid state with an unspecified value.
-**Table: `basic_string(const basic_string&)` effects** <a id="tab:strings.ctr.cpy">[tab:strings.ctr.cpy]</a>
-| Element      | Value                                                                                                           |
-| ------------ | --------------------------------------------------------------------------------------------------------------- |
-| `data()`     | points at the first element of an allocated copy of the array whose first element is pointed at by `str.data()` |
-| `size()`     | `str.size()`                                                                                                    |
-| `capacity()` | a value at least as large as `size()`                                                                           |
 ``` cpp
-basic_string(const basic_string& str, size_type pos,
                        const Allocator& a = Allocator());
 ```
-*Throws:* `out_of_range` if `pos > str.size()`.
-*Effects:* Constructs an object of class `basic_string` and determines
-the effective length `rlen` of the initial string value as
-`str.size() - pos`, as indicated in Table  [[tab:strings.ctr.2]].
 ``` cpp
-basic_string(const basic_string& str, size_type pos, size_type n,
-             const Allocator& a = Allocator());
 ```
-*Throws:* `out_of_range` if `pos > str.size()`.
-*Effects:* Constructs an object of class `basic_string` and determines
-the effective length `rlen` of the initial string value as the smaller
-of `n` and `str.size() - pos`, as indicated in
-Table  [[tab:strings.ctr.2]].
-**Table: `basic_string(const basic_string&, size_type, const Allocator&)`\protect\mbox{ }and\protect
-`basic_string(const basic_string&, size_type, size_type, const Allocator&)` effects** <a id="tab:strings.ctr.2">[tab:strings.ctr.2]</a>
-| Element      | Value                                                                                                                                         |
-| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------- |
-| `data()`     | points at the first element of an allocated copy of `rlen` consecutive elements of the string controlled by `str` beginning at position `pos` |
-| `size()`     | `rlen`                                                                                                                                        |
-| `capacity()` | a value at least as large as `size()`                                                                                                         |
 ``` cpp
 template<class T>
-  basic_string(const T& t, size_type pos, size_type n,
-               const Allocator& a = Allocator());
 ```
 *Effects:* Creates a variable, `sv`, as if by
 `basic_string_view<charT, traits> sv = t;` and then behaves the same as:
 ``` cpp
 basic_string(sv.substr(pos, n), a);
 ```
-*Remarks:* This constructor shall not participate in overload resolution
-unless `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
-`true`.
 ``` cpp
-explicit basic_string(basic_string_view<charT, traits> sv,
- const Allocator& a = Allocator());
 ```
-*Effects:* Same as `basic_string(sv.data(), sv.size(), a)`.
 ``` cpp
-basic_string(const charT* s, size_type n,
-             const Allocator& a = Allocator());
 ```
-*Requires:* `s` points to an array of at least `n` elements of `charT`.
-*Effects:* Constructs an object of class `basic_string` and determines
-its initial string value from the array of `charT` of length `n` whose
-first element is designated by `s`, as indicated in
-Table  [[tab:strings.ctr.3]].
-**Table: `basic_string(const charT*, size_type, const Allocator&)` effects** <a id="tab:strings.ctr.3">[tab:strings.ctr.3]</a>
-| Element      | Value                                                                                                  |
-| ------------ | ------------------------------------------------------------------------------------------------------ |
-| `data()`     | points at the first element of an allocated copy of the array whose first element is pointed at by `s` |
-| `size()`     | `n`                                                                                                    |
-| `capacity()` | a value at least as large as `size()`                                                                  |
 ``` cpp
-basic_string(const charT* s, const Allocator& a = Allocator());
 ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Effects:* Constructs an object of class `basic_string` and determines
-its initial string value from the array of `charT` of length
-`traits::length(s)` whose first element is designated by `s`, as
-indicated in Table  [[tab:strings.ctr.4]].
-**Table: `basic_string(const charT*, const Allocator&)` effects** <a id="tab:strings.ctr.4">[tab:strings.ctr.4]</a>
-| Element      | Value                                                                                                  |
-| ------------ | ------------------------------------------------------------------------------------------------------ |
-| `data()`     | points at the first element of an allocated copy of the array whose first element is pointed at by `s` |
-| `size()`     | `traits::length(s)`                                                                                    |
-| `capacity()` | a value at least as large as `size()`                                                                  |
 ``` cpp
-basic_string(size_type n, charT c, const Allocator& a = Allocator());
 ```
-*Requires:* `n < npos`.
-*Effects:* Constructs an object of class `basic_string` and determines
-its initial string value by repeating the char-like object `c` for all
-`n` elements, as indicated in Table  [[tab:strings.ctr.5]].
-**Table: `basic_string(size_t, charT, const Allocator&)` effects** <a id="tab:strings.ctr.5">[tab:strings.ctr.5]</a>
-| Element      | Value                                                                                                 |
-| ------------ | ----------------------------------------------------------------------------------------------------- |
-| `data()`     | points at the first element of an allocated array of `n` elements, each storing the initial value `c` |
-| `size()`     | `n`                                                                                                   |
-| `capacity()` | a value at least as large as `size()`                                                                 |
 ``` cpp
 template<class InputIterator>
-  basic_string(InputIterator begin, InputIterator end,
-               const Allocator& a = Allocator());
 ```
-*Effects:* If `InputIterator` is an integral type, equivalent to:
-``` cpp
-basic_string(static_cast<size_type>(begin), static_cast<value_type>(end), a);
-```
-Otherwise constructs a string from the values in the range \[`begin`,
-`end`), as indicated in the Sequence Requirements table
-(see  [[sequence.reqmts]]).
 ``` cpp
-basic_string(initializer_list<charT> il, const Allocator& a = Allocator());
 ```
-*Effects:* Same as `basic_string(il.begin(), il.end(), a)`.
 ``` cpp
-basic_string(const basic_string& str, const Allocator& alloc);
-basic_string(basic_string&& str, const Allocator& alloc);
 ```
-*Effects:* Constructs an object of class `basic_string` as indicated in
-Table  [[tab:strings.ctr.6]]. The stored allocator is constructed from
-`alloc`. In the second form, `str` is left in a valid state with an
-unspecified value.
-**Table: `basic_string(const basic_string&, const Allocator&)`\protect and
-`basic_string(basic_string&&, const Allocator&)` effects** <a id="tab:strings.ctr.6">[tab:strings.ctr.6]</a>
-| Element           | Value                                                                                                                                  |
-| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
-| `data()`          | points at the first element of an allocated copy of the array whose first element is pointed at by the original value of `str.data()`. |
-| `size()`          | the original value of `str.size()`                                                                                                     |
-| `capacity()`      | a value at least as large as `size()`                                                                                                  |
-| `get_allocator()` | `alloc`                                                                                                                                |
 *Throws:* The second form throws nothing if
 `alloc == str.get_allocator()`.
 ``` cpp
@@ -529,226 +474,236 @@ template<class InputIterator,
     -> basic_string<typename iterator_traits<InputIterator>::value_type,
                     char_traits<typename iterator_traits<InputIterator>::value_type>,
                     Allocator>;
 ```
-*Remarks:* Shall not participate in overload resolution if
-`InputIterator` is a type that does not qualify as an input iterator, or
-if `Allocator` is a type that does not qualify as an
-allocator ([[container.requirements.general]]).
 ``` cpp
-basic_string& operator=(const basic_string& str);
 ```
-*Effects:* If `*this` and `str` are not the same object, modifies
-`*this` as shown in Table  [[tab:strings.op=]].
-If `*this` and `str` are the same object, the member has no effect.
 *Returns:* `*this`.
-**Table: `operator=(const basic_string&)` effects** <a id="tab:strings.op=">[tab:strings.op=]</a>
-| Element      | Value                                                                                                           |
-| ------------ | --------------------------------------------------------------------------------------------------------------- |
-| `data()`     | points at the first element of an allocated copy of the array whose first element is pointed at by `str.data()` |
-| `size()`     | `str.size()`                                                                                                    |
-| `capacity()` | a value at least as large as `size()`                                                                           |
 ``` cpp
-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
-basic_string& operator=(basic_string_view<charT, traits> sv);
 ```
-*Effects:* Equivalent to: `return assign(sv);`
 ``` cpp
-basic_string& operator=(const charT* s);
 ```
-*Returns:* `*this = basic_string(s)`.
-*Remarks:* Uses `traits::length()`.
 ``` cpp
-basic_string& operator=(charT c);
 ```
-*Returns:* `*this = basic_string(1, c)`.
 ``` cpp
-basic_string& operator=(initializer_list<charT> il);
 ```
-*Effects:* As if by: `*this = basic_string(il);`
-*Returns:* `*this`.
-#### `basic_string` iterator support <a id="string.iterators">[[string.iterators]]</a>
 ``` cpp
-iterator       begin() noexcept;
-const_iterator begin() const noexcept;
-const_iterator cbegin() const noexcept;
 ```
 *Returns:* An iterator referring to the first character in the string.
 ``` cpp
-iterator       end() noexcept;
-const_iterator end() const noexcept;
-const_iterator cend() const noexcept;
 ```
 *Returns:* An iterator which is the past-the-end value.
 ``` cpp
-reverse_iterator       rbegin() noexcept;
-const_reverse_iterator rbegin() const noexcept;
-const_reverse_iterator crbegin() const noexcept;
 ```
 *Returns:* An iterator which is semantically equivalent to
 `reverse_iterator(end())`.
 ``` cpp
-reverse_iterator       rend() noexcept;
-const_reverse_iterator rend() const noexcept;
-const_reverse_iterator crend() const noexcept;
 ```
 *Returns:* An iterator which is semantically equivalent to
 `reverse_iterator(begin())`.
-#### `basic_string` capacity <a id="string.capacity">[[string.capacity]]</a>
 ``` cpp
-size_type size() const noexcept;
 ```
 *Returns:* A count of the number of char-like objects currently in the
 string.
 *Complexity:* Constant time.
 ``` cpp
-size_type length() const noexcept;
-```
-*Returns:* `size()`.
-``` cpp
-size_type max_size() const noexcept;
 ```
 *Returns:* The largest possible number of char-like objects that can be
 stored in a `basic_string`.
 *Complexity:* Constant time.
 ``` cpp
-void resize(size_type n, charT c);
 ```
-*Throws:* `length_error` if `n > max_size()`.
-*Effects:* Alters the length of the string designated by `*this` as
-follows:
-- If `n <= size()`, the function replaces the string designated by
-  `*this` with a string of length `n` whose elements are a copy of the
-  initial elements of the original string designated by `*this`.
-- If `n > size()`, the function replaces the string designated by
-  `*this` with a string of length `n` whose first `size()` elements are
-  a copy of the original string designated by `*this`, and whose
-  remaining elements are all initialized to `c`.
 ``` cpp
-void resize(size_type n);
 ```
-*Effects:* As if by `resize(n, charT())`.
 ``` cpp
-size_type capacity() const noexcept;
 ```
 *Returns:* The size of the allocated storage in the string.
 ``` cpp
-void reserve(size_type res_arg=0);
 ```
-The member function `reserve()` is a directive that informs a
-`basic_string` object of a planned change in size, so that it can manage
-the storage allocation accordingly.
-*Effects:* After `reserve()`, `capacity()` is greater or equal to the
-argument of `reserve`.
-[*Note 1*: Calling `reserve()` with a `res_arg` argument less than
-`capacity()` is in effect a non-binding shrink request. A call with
-`res_arg <= size()` is in effect a non-binding shrink-to-fit
-request. — *end note*]
-*Throws:* `length_error` if `res_arg > max_size()`.[^4]
 ``` cpp
-void shrink_to_fit();
 ```
 *Effects:* `shrink_to_fit` is a non-binding request to reduce
 `capacity()` to `size()`.
-[*Note 2*: The request is non-binding to allow latitude for
 implementation-specific optimizations. — *end note*]
 It does not increase `capacity()`, but may reduce `capacity()` by
 causing reallocation.
-*Complexity:* Linear in the size of the sequence.
 *Remarks:* Reallocation invalidates all the references, pointers, and
-iterators referring to the elements in the sequence as well as the
-past-the-end iterator. If no reallocation happens, they remain valid.
-``` cpp
-void clear() noexcept;
-```
-*Effects:* Behaves as if the function calls:
 ``` cpp
-erase(begin(), end());
 ```
 ``` cpp
-bool empty() const noexcept;
 ```
-*Returns:* `size() == 0`.
-#### `basic_string` element access <a id="string.access">[[string.access]]</a>
 ``` cpp
-const_reference operator[](size_type pos) const;
-reference       operator[](size_type pos);
 ```
-*Requires:* `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.
@@ -756,1026 +711,800 @@ undefined behavior.
 *Throws:* Nothing.
 *Complexity:* Constant time.
 ``` cpp
-const_reference at(size_type pos) const;
-reference       at(size_type pos);
 ```
 *Throws:* `out_of_range` if `pos >= size()`.
 *Returns:* `operator[](pos)`.
 ``` cpp
-const charT& front() const;
-charT& front();
 ```
-*Requires:* `!empty()`.
 *Effects:* Equivalent to: `return operator[](0);`
 ``` cpp
-const charT& back() const;
-charT& back();
 ```
-*Requires:* `!empty()`.
 *Effects:* Equivalent to: `return operator[](size() - 1);`
-#### `basic_string` modifiers <a id="string.modifiers">[[string.modifiers]]</a>
-##### `basic_string::operator+=` <a id="string.op+=">[[string.op+=]]</a>
 ``` cpp
-basic_string&
-  operator+=(const basic_string& str);
 ```
-*Effects:* Calls `append(str)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& operator+=(basic_string_view<charT, traits> sv);
 ```
-*Effects:* Calls `append(sv)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& operator+=(const charT* s);
 ```
-*Effects:* Calls `append(s)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& operator+=(charT c);
 ```
-*Effects:* Calls `push_back(c)`;
-*Returns:* `*this`.
 ``` cpp
-basic_string& operator+=(initializer_list<charT> il);
 ```
-*Effects:* Calls `append(il)`.
-*Returns:* `*this`.
 ##### `basic_string::append` <a id="string.append">[[string.append]]</a>
 ``` cpp
-basic_string&
-  append(const basic_string& str);
 ```
-*Effects:* Calls `append(str.data(), str.size())`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  append(const basic_string& str, size_type pos, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos > str.size()`.
-*Effects:* Determines the effective length `rlen` of the string to
-append as the smaller of `n` and `str``.size() - ``pos` and calls
-`append(str.data() + pos, rlen)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& append(basic_string_view<charT, traits> sv);
 ```
-*Effects:* Equivalent to: `return append(sv.data(), sv.size());`
 ``` cpp
 template<class T>
-  basic_string& append(const T& t, size_type pos, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos > sv.size()`.
-*Effects:* Creates a variable, `sv`, as if by
-`basic_string_view<charT, traits> sv = t`. Determines the effective
-length `rlen` of the string to append as the smaller of `n` and
-`sv.size() - pos` and calls `append(sv.data() + pos, rlen)`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
-`true` and `is_convertible_v<const T&, const charT*>` is `false`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  append(const charT* s, size_type n);
 ```
-*Requires:* `s` points to an array of at least `n` elements of `charT`.
-*Throws:* `length_error` if `size() + n > max_size()`.
-*Effects:* The function replaces the string controlled by `*this` with a
-string of length `size() + n` whose first `size()` elements are a copy
-of the original string controlled by `*this` and whose remaining
-elements are a copy of the initial `n` elements of `s`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& append(const charT* s);
 ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Effects:* Calls `append(s, traits::length(s))`.
 *Returns:* `*this`.
 ``` cpp
-basic_string& append(size_type n, charT c);
 ```
-*Effects:* Equivalent to `append(basic_string(n, c))`.
 *Returns:* `*this`.
 ``` cpp
 template<class InputIterator>
-  basic_string& append(InputIterator first, InputIterator last);
 ```
-*Requires:* \[`first`, `last`) is a valid range.
-*Effects:* Equivalent to
-`append(basic_string(first, last, get_allocator()))`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& append(initializer_list<charT> il);
 ```
-*Effects:* Calls `append(il.begin(), il.size())`.
-*Returns:* `*this`.
 ``` cpp
-void push_back(charT c);
 ```
-*Effects:* Equivalent to `append(static_cast<size_type>(1), c)`.
 ##### `basic_string::assign` <a id="string.assign">[[string.assign]]</a>
 ``` cpp
-basic_string& assign(const basic_string& str);
 ```
-*Effects:* Equivalent to `*this = str`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& assign(basic_string&& str)
   noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
-*Effects:* Equivalent to `*this = std::move(str)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  assign(const basic_string& str, size_type pos,
-         size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos > str.size()`.
-*Effects:* Determines the effective length `rlen` of the string to
-assign as the smaller of `n` and `str``.size() - ``pos` and calls
-`assign(str.data() + pos, rlen)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& assign(basic_string_view<charT, traits> sv);
 ```
-*Effects:* Equivalent to: `return assign(sv.data(), sv.size());`
 ``` cpp
 template<class T>
-  basic_string& assign(const T& t, size_type pos, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos > sv.size()`.
-*Effects:* Creates a variable, `sv`, as if by
-`basic_string_view<charT, traits> sv = t`. Determines the effective
-length `rlen` of the string to assign as the smaller of `n` and
-`sv.size() - pos` and calls `assign(sv.data() + pos, rlen)`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
-`true` and `is_convertible_v<const T&, const charT*>` is `false`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& assign(const charT* s, size_type n);
 ```
-*Requires:* `s` points to an array of at least `n` elements of `charT`.
-*Throws:* `length_error` if `n > max_size()`.
-*Effects:* Replaces the string controlled by `*this` with a string of
-length `n` whose elements are a copy of those pointed to by `s`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& assign(const charT* s);
 ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Effects:* Calls `assign(s, traits::length(s))`.
 *Returns:* `*this`.
 ``` cpp
-basic_string& assign(initializer_list<charT> il);
 ```
-*Effects:* Calls `assign(il.begin(), il.size())`.
-`*this`.
 ``` cpp
-basic_string& assign(size_type n, charT c);
 ```
-*Effects:* Equivalent to `assign(basic_string(n, c))`.
-*Returns:* `*this`.
 ``` cpp
 template<class InputIterator>
-  basic_string& assign(InputIterator first, InputIterator last);
 ```
-*Effects:* Equivalent to
-`assign(basic_string(first, last, get_allocator()))`.
-*Returns:* `*this`.
 ##### `basic_string::insert` <a id="string.insert">[[string.insert]]</a>
 ``` cpp
-basic_string&
-  insert(size_type pos,
-         const basic_string& str);
 ```
 *Effects:* Equivalent to: `return insert(pos, str.data(), str.size());`
 ``` cpp
-basic_string&
-  insert(size_type pos1,
-         const basic_string& str,
                                size_type pos2, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos1 > size()` or `pos2 > str.size()`.
-*Effects:* Determines the effective length `rlen` of the string to
-insert as the smaller of `n` and `str.size() - pos2` and calls
-`insert(pos1, str.data() + pos2, rlen)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& insert(size_type pos, basic_string_view<charT, traits> sv);
 ```
-*Effects:* Equivalent to: `return insert(pos, sv.data(), sv.size());`
 ``` cpp
 template<class T>
-  basic_string& insert(size_type pos1, const T& t,
                                  size_type pos2, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos1 > size()` or `pos2 > sv.size()`.
-*Effects:* Creates a variable, `sv`, as if by
-`basic_string_view<charT, traits> sv = t`. Determines the effective
-length `rlen` of the string to assign as the smaller of `n` and
-`sv.size() - pos2` and calls `insert(pos1, sv.data() + pos2, rlen)`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
-`true` and `is_convertible_v<const T&, const charT*>` is `false`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  insert(size_type pos, const charT* s, size_type n);
 ```
-*Requires:* `s` points to an array of at least `n` elements of `charT`.
-*Throws:* `out_of_range` if `pos > size()` or `length_error` if
-`size() + n > max_size()`.
-*Effects:* Replaces the string controlled by `*this` with a string of
-length `size() + n` whose first `pos` elements are a copy of the initial
-elements of the original string controlled by `*this` and whose next `n`
-elements are a copy of the elements in `s` and whose remaining elements
-are a copy of the remaining elements of the original string controlled
-by `*this`.
 *Returns:* `*this`.
 ``` cpp
-basic_string&
-  insert(size_type pos, const charT* s);
 ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
 *Effects:* Equivalent to: `return insert(pos, s, traits::length(s));`
 ``` cpp
-basic_string&
-  insert(size_type pos, size_type n, charT c);
 ```
-*Effects:* Equivalent to `insert(pos, basic_string(n, c))`.
-*Returns:* `*this`.
 ``` cpp
-iterator insert(const_iterator p, charT c);
 ```
-*Requires:* `p` is a valid iterator on `*this`.
-*Effects:* Inserts a copy of `c` before the character referred to by
-`p`.
-*Returns:* An iterator which refers to the copy of the inserted
-character.
 ``` cpp
-iterator insert(const_iterator p, size_type n, charT c);
 ```
-*Requires:* `p` is a valid iterator on `*this`.
-*Effects:* Inserts `n` copies of `c` before the character referred to by
-`p`.
-*Returns:* An iterator which refers to the copy of the first inserted
-character, or `p` if `n == 0`.
 ``` cpp
 template<class InputIterator>
-  iterator insert(const_iterator p, InputIterator first, InputIterator last);
 ```
-*Requires:* `p` is a valid iterator on `*this`. `[first, last)` is a
-valid range.
 *Effects:* Equivalent to
 `insert(p - begin(), basic_string(first, last, get_allocator()))`.
-*Returns:* An iterator which refers to the copy of the first inserted
-character, or `p` if `first == last`.
 ``` cpp
-iterator insert(const_iterator p, initializer_list<charT> il);
 ```
-*Effects:* As if by `insert(p, il.begin(), il.end())`.
-*Returns:* An iterator which refers to the copy of the first inserted
-character, or `p` if `i1` is empty.
 ##### `basic_string::erase` <a id="string.erase">[[string.erase]]</a>
 ``` cpp
-basic_string& erase(size_type pos = 0, size_type n = npos);
 ```
 *Throws:* `out_of_range` if `pos` `> size()`.
 *Effects:* Determines the effective length `xlen` of the string to be
-removed as the smaller of `n` and `size() - pos`.
-The function then replaces the string controlled by `*this` with a
-string of length `size() - xlen` whose first `pos` elements are a copy
-of the initial elements of the original string controlled by `*this`,
-and whose remaining elements are a copy of the elements of the original
-string controlled by `*this` beginning at position `pos + xlen`.
 *Returns:* `*this`.
 ``` cpp
-iterator erase(const_iterator p);
 ```
 *Throws:* Nothing.
 *Effects:* Removes the character referred to by `p`.
 *Returns:* An iterator which points to the element immediately following
 `p` prior to the element being erased. If no such element exists,
 `end()` is returned.
 ``` cpp
-iterator erase(const_iterator first, const_iterator last);
 ```
-*Requires:* `first` and `last` are valid iterators on `*this`, defining
-a range `[first, last)`.
 *Throws:* Nothing.
 *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
-void pop_back();
 ```
-*Requires:* `!empty()`.
 *Throws:* Nothing.
-*Effects:* Equivalent to `erase(size() - 1, 1)`.
 ##### `basic_string::replace` <a id="string.replace">[[string.replace]]</a>
 ``` cpp
-basic_string&
-  replace(size_type pos1, size_type n1,
-          const basic_string& str);
 ```
 *Effects:* Equivalent to:
 `return replace(pos1, n1, str.data(), str.size());`
 ``` cpp
-basic_string&
-  replace(size_type pos1, size_type n1,
-          const basic_string& str,
                                 size_type pos2, size_type n2 = npos);
 ```
-*Throws:* `out_of_range` if `pos1 > size()` or `pos2 > str.size()`.
-*Effects:* Determines the effective length `rlen` of the string to be
-inserted as the smaller of `n2` and `str.size() - pos2` and calls
-`replace(pos1, n1, str.data() + pos2, rlen)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(size_type pos1, size_type n1,
-                      basic_string_view<charT, traits> sv);
 ```
 *Effects:* Equivalent to:
-`return replace(pos1, n1, sv.data(), sv.size());`
 ``` cpp
 template<class T>
-  basic_string& replace(size_type pos1, size_type n1, const T& t,
                                   size_type pos2, size_type n2 = npos);
 ```
-*Throws:* `out_of_range` if `pos1 > size()` or `pos2 > sv.size()`.
-*Effects:* Creates a variable, `sv`, as if by
-`basic_string_view<charT, traits> sv = t`. Determines the effective
-length `rlen` of the string to be inserted as the smaller of `n2` and
-`sv.size() - pos2` and calls
-`replace(pos1, n1, sv.data() + pos2, rlen)`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
-`true` and `is_convertible_v<const T&, const charT*>` is `false`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  replace(size_type pos1, size_type n1, const charT* s, size_type n2);
 ```
-*Requires:* `s` points to an array of at least `n2` elements of `charT`.
-*Throws:* `out_of_range` if `pos1 > size()` or `length_error` if the
-length of the resulting string would exceed `max_size()` (see below).
 *Effects:* Determines the effective length `xlen` of the string to be
 removed as the smaller of `n1` and `size() - pos1`. If
 `size() - xlen >= max_size() - n2` throws `length_error`. Otherwise, the
-function replaces the string controlled by \*`this` with a string of
-length `size() - xlen + n2` whose first `pos1` elements are a copy of
-the initial elements of the original string controlled by `*this`, whose
-next `n2` elements are a copy of the initial `n2` elements of `s`, and
-whose remaining elements are a copy of the elements of the original
-string controlled by `*this` beginning at position `pos + xlen`.
 *Returns:* `*this`.
 ``` cpp
-basic_string&
-  replace(size_type pos, size_type n, const charT* s);
 ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
 *Effects:* Equivalent to:
 `return replace(pos, n, s, traits::length(s));`
 ``` cpp
-basic_string&
-  replace(size_type pos1, size_type n1,
-          size_type n2, charT c);
 ```
-*Effects:* Equivalent to `replace(pos1, n1, basic_string(n2, c))`.
 *Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, str)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2,
-                      basic_string_view<charT, traits> sv);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, sv)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
- replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges and
-`s` points to an array of at least `n` elements of `charT`.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, s, n)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges and
-`s` points to an array of at least `traits::length(s) + 1` elements of
-`charT`.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, s, traits::length(s))`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2, size_type n,
-                      charT c);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, basic_string(n, c))`.
-*Returns:* `*this`.
 ``` cpp
 template<class InputIterator>
-  basic_string& replace(const_iterator i1, const_iterator i2,
                                   InputIterator j1, InputIterator j2);
 ```
-*Requires:* \[`begin()`, `i1`), \[`i1`, `i2`) and \[`j1`, `j2`) are
-valid ranges.
-*Effects:* Calls
-`replace(i1 - begin(), i2 - i1, basic_string(j1, j2, get_allocator()))`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2,
-                      initializer_list<charT> il);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
-*Effects:* Calls
-`replace(i1 - begin(), i2 - i1, il.begin(), il.size())`.
-*Returns:* `*this`.
 ##### `basic_string::copy` <a id="string.copy">[[string.copy]]</a>
 ``` cpp
-size_type copy(charT* s, size_type n, size_type pos = 0) const;
 ```
-Let `rlen` be the smaller of `n` and `size() - pos`.
-*Throws:* `out_of_range` if `pos > size()`.
-*Requires:* \[`s`, `s + rlen`) is a valid range.
-*Effects:* Equivalent to: `traits::copy(s, data() + pos, rlen)`.
 [*Note 1*: This does not terminate `s` with a null
 object. — *end note*]
-*Returns:* `rlen`.
 ##### `basic_string::swap` <a id="string.swap">[[string.swap]]</a>
 ``` cpp
-void swap(basic_string& s)
   noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
-*Postconditions:* `*this` contains the same sequence of characters that
-was in `s`, `s` contains the same sequence of characters that was in
-`*this`.
 *Throws:* Nothing.
 *Complexity:* Constant time.
-#### `basic_string` string operations <a id="string.ops">[[string.ops]]</a>
-##### `basic_string` accessors <a id="string.accessors">[[string.accessors]]</a>
 ``` cpp
-const charT* c_str() const noexcept;
-const charT* data() const noexcept;
 ```
-*Returns:* A pointer `p` such that `p + i == &operator[](i)` for each
-`i` in \[`0`, `size()`\].
 *Complexity:* Constant time.
-*Requires:* The program shall not alter any of the values stored in the
-character array.
 ``` cpp
-charT* data() noexcept;
 ```
-*Returns:* A pointer `p` such that `p + i == &operator[](i)` for each
-`i` in \[`0`, `size()`\].
 *Complexity:* Constant time.
-*Requires:* The program shall not alter the value stored at
-`p + size()`.
 ``` cpp
-operator basic_string_view<charT, traits>() const noexcept;
 ```
 *Effects:* Equivalent to:
 `return basic_string_view<charT, traits>(data(), size());`
 ``` cpp
-allocator_type get_allocator() const noexcept;
 ```
 *Returns:* A copy of the `Allocator` object used to construct the string
 or, if that allocator has been replaced, a copy of the most recent
 replacement.
-##### `basic_string::find` <a id="string.find">[[string.find]]</a>
-``` cpp
-size_type find(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
-```
-*Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions hold:
-- `pos <= xpos` and `xpos + sv.size() <= size()`;
-- `traits::eq(at(xpos + I), sv.at(I))` for all elements `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
-``` cpp
-size_type find(const basic_string& str, size_type pos = 0) const noexcept;
-```
-*Effects:* Equivalent to:
-`return find(basic_string_view<charT, traits>(str), pos);`
-``` cpp
-size_type find(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:* `find(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find(const charT* s, size_type pos = 0) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `find(basic_string_view<charT, traits>(s), pos)`.
-``` cpp
-size_type find(charT c, size_type pos = 0) const;
-```
-*Returns:* `find(basic_string(1, c), pos)`.
-##### `basic_string::rfind` <a id="string.rfind">[[string.rfind]]</a>
-``` cpp
-size_type rfind(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
-```
-*Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions hold:
-- `xpos <= pos` and `xpos + sv.size() <= size()`;
-- `traits::eq(at(xpos + I), sv.at(I))` for all elements `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
-``` cpp
-size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
-```
-*Effects:* Equivalent to:
-`return rfind(basic_string_view<charT, traits>(str), pos);`
-``` cpp
-size_type rfind(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:* `rfind(basic_string_view<charT, traits>(s, n), pos)`.
   ``` cpp
-size_type rfind(const charT* s, size_type pos = npos) const;
   ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `rfind(basic_string_view<charT, traits>(s), pos)`.
   ``` cpp
-size_type rfind(charT c, size_type pos = npos) const;
   ```
-*Returns:* `rfind(basic_string(1, c), pos)`.
-##### `basic_string::find_first_of` <a id="string.find.first.of">[[string.find.first.of]]</a>
   ``` cpp
-size_type find_first_of(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
   ```
-*Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions hold:
-- `pos <= xpos` and `xpos < size()`;
-- `traits::eq(at(xpos), sv.at(I))` for some element `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
   ``` cpp
-size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
   ```
-*Effects:* Equivalent to:
-`return find_first_of(basic_string_view<charT, traits>(str), pos);`
   ``` cpp
-size_type find_first_of(const charT* s, size_type pos, size_type n) const;
   ```
-*Returns:* `find_first_of(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find_first_of(const charT* s, size_type pos = 0) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `find_first_of(basic_string_view<charT, traits>(s), pos)`.
-``` cpp
-size_type find_first_of(charT c, size_type pos = 0) const;
-```
-*Returns:* `find_first_of(basic_string(1, c), pos)`.
-##### `basic_string::find_last_of` <a id="string.find.last.of">[[string.find.last.of]]</a>
-``` cpp
-size_type find_last_of(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
-```
-*Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions hold:
-- `xpos <= pos` and `xpos < size()`;
-- `traits::eq(at(xpos), sv.at(I))` for some element `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
 ``` cpp
-size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept;
 ```
-*Effects:* Equivalent to:
-`return find_last_of(basic_string_view<charT, traits>(str), pos);`
-``` cpp
-size_type find_last_of(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:* `find_last_of(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find_last_of(const charT* s, size_type pos = npos) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `find_last_of(basic_string_view<charT, traits>(s), pos)`.
-``` cpp
-size_type find_last_of(charT c, size_type pos = npos) const;
-```
-*Returns:* `find_last_of(basic_string(1, c), pos)`.
-##### `basic_string::find_first_not_of` <a id="string.find.first.not.of">[[string.find.first.not.of]]</a>
-``` cpp
-size_type find_first_not_of(basic_string_view<charT, traits> sv,
-                            size_type pos = 0) const noexcept;
-```
-*Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions hold:
-- `pos <= xpos` and `xpos < size()`;
-- `traits::eq(at(xpos), sv.at(I))` for no element `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
-``` cpp
-size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept;
-```
-*Effects:* Equivalent to:
-``` cpp
-return find_first_not_of(basic_string_view<charT, traits>(str), pos);
-```
-``` cpp
-size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:*
-`find_first_not_of(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find_first_not_of(const charT* s, size_type pos = 0) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:*
-`find_first_not_of(basic_string_view<charT, traits>(s), pos)`.
-``` cpp
-size_type find_first_not_of(charT c, size_type pos = 0) const;
-```
-*Returns:* `find_first_not_of(basic_string(1, c), pos)`.
-##### `basic_string::find_last_not_of` <a id="string.find.last.not.of">[[string.find.last.not.of]]</a>
-``` cpp
-size_type find_last_not_of(basic_string_view<charT, traits> sv,
-                           size_type pos = npos) const noexcept;
-```
-*Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions hold:
-- `xpos <= pos` and `xpos < size()`;
-- `traits::eq(at(xpos), sv.at(I))` for no element `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
-``` cpp
-size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept;
-```
-*Effects:* Equivalent to:
-``` cpp
-return find_last_not_of(basic_string_view<charT, traits>(str), pos);
-```
-``` cpp
-size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:*
-`find_last_not_of(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find_last_not_of(const charT* s, size_type pos = npos) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `find_last_not_of(basic_string_view<charT, traits>(s), pos)`.
 ``` cpp
-size_type find_last_not_of(charT c, size_type pos = npos) const;
 ```
-*Returns:* `find_last_not_of(basic_string(1, c), pos)`.
 ##### `basic_string::substr` <a id="string.substr">[[string.substr]]</a>
 ``` cpp
-basic_string substr(size_type pos = 0, size_type n = npos) const;
 ```
 *Throws:* `out_of_range` if `pos > size()`.
 *Effects:* Determines the effective length `rlen` of the string to copy
@@ -1784,97 +1513,131 @@ as the smaller of `n` and `size() - pos`.
 *Returns:* `basic_string(data()+pos, rlen)`.
 ##### `basic_string::compare` <a id="string.compare">[[string.compare]]</a>
 ``` cpp
-int compare(basic_string_view<charT, traits> sv) const noexcept;
 ```
-*Effects:* Determines the effective length `rlen` of the strings to
-compare as the smaller of `size()` and `sv.size()`. The function then
-compares the two strings by calling
-`traits::compare(data(), sv.data(), rlen)`.
-*Returns:* The nonzero result if the result of the comparison is
-nonzero. Otherwise, returns a value as indicated in
-Table  [[tab:strings.compare]].
-**Table: `compare()` results** <a id="tab:strings.compare">[tab:strings.compare]</a>
-| Condition             | Return Value |
-| --------------------- | ------------ |
-| `size() <  sv.size()` | `< 0`        |
-| `size() == sv.size()` | `  0`        |
-| `size() >  sv.size()` | `> 0`        |
 ``` cpp
-int compare(size_type pos1, size_type n1, basic_string_view<charT, traits> sv) const;
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return basic_string_view<charT, traits>(data(), size()).substr(pos1, n1).compare(sv);
 ```
 ``` cpp
 template<class T>
-  int compare(size_type pos1, size_type n1, const T& t,
                         size_type pos2, size_type n2 = npos) const;
 ```
 *Effects:* Equivalent to:
 ``` cpp
-basic_string_view<charT, traits> sv = t;
-return basic_string_view<charT, traits>(
-    data(), size()).substr(pos1, n1).compare(sv.substr(pos2, n2));
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
-`true` and `is_convertible_v<const T&, const charT*>` is `false`.
 ``` cpp
-int compare(const basic_string& str) const noexcept;
 ```
 *Effects:* Equivalent to:
 `return compare(basic_string_view<charT, traits>(str));`
 ``` cpp
-int compare(size_type pos1, size_type n1, const basic_string& str) const;
 ```
 *Effects:* Equivalent to:
 `return compare(pos1, n1, basic_string_view<charT, traits>(str));`
 ``` cpp
-int compare(size_type pos1, size_type n1,
-            const basic_string& str,
                       size_type pos2, size_type n2 = npos) const;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return compare(pos1, n1, basic_string_view<charT, traits>(str), pos2, n2);
 ```
 ``` cpp
-int compare(const charT* s) const;
 ```
-*Returns:* `compare(basic_string(s))`.
 ``` cpp
-int compare(size_type pos, size_type n1, const charT* s) const;
 ```
-*Returns:* `basic_string(*this, pos, n1).compare(basic_string(s))`.
 ``` cpp
-int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
 ```
-*Returns:* `basic_string(*this, pos, n1).compare(basic_string(s, n2))`.

 is also called a “string” if the type of the char-like objects that it
 holds is clear from context. In the rest of this Clause, the type of the
 char-like objects held in a `basic_string` object is designated by
 `charT`.
+A specialization of `basic_string` is a contiguous container
+[[container.requirements.general]].
+In all cases, \[`data()`, `data() + size()`\] is a valid range,
+`data() + size()` points at an object with value `charT()` (a “null
+terminator”), and `size() <= capacity()` is `true`.
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
   class basic_string {
   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 reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     static const size_type npos  = -1;
     // [string.cons], construct/copy/destroy
+ constexpr basic_string() noexcept(noexcept(Allocator())) : basic_string(Allocator()) { }
+ constexpr explicit basic_string(const Allocator& a) noexcept;
+ constexpr basic_string(const basic_string& str);
+ constexpr basic_string(basic_string&& str) noexcept;
+ constexpr basic_string(const basic_string& str, size_type pos,
                            const Allocator& a = Allocator());
+ constexpr basic_string(const basic_string& str, size_type pos, size_type n,
                            const Allocator& a = Allocator());
     template<class T>
+ constexpr basic_string(const T& t, size_type pos, size_type n,
                              const Allocator& a = Allocator());
+ template<class T>
+      constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
+ constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
+    constexpr basic_string(const charT* s, const Allocator& a = Allocator());
+ constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
     template<class InputIterator>
+ constexpr basic_string(InputIterator begin, InputIterator end,
                              const Allocator& a = Allocator());
+ constexpr basic_string(initializer_list<charT>, const Allocator& = Allocator());
+ constexpr basic_string(const basic_string&, const Allocator&);
+ constexpr basic_string(basic_string&&, const Allocator&);
+    constexpr ~basic_string();
+ 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);
+ template<class T>
+      constexpr basic_string& operator=(const T& t);
+ constexpr basic_string& operator=(const charT* s);
+ constexpr basic_string& operator=(charT c);
+    constexpr basic_string& operator=(initializer_list<charT>);
     // [string.iterators], iterators
+ constexpr iterator       begin() noexcept;
+ constexpr const_iterator begin() const noexcept;
+ constexpr iterator       end() noexcept;
+ constexpr const_iterator end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // [string.capacity], capacity
+ constexpr size_type size() const noexcept;
+ constexpr size_type length() const noexcept;
+ constexpr size_type max_size() const noexcept;
+ constexpr void resize(size_type n, charT c);
+ constexpr void resize(size_type n);
+ 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;
+ constexpr reference       at(size_type n);
+ constexpr const charT& front() const;
+ constexpr charT&       front();
+ constexpr const charT& back() const;
+ constexpr charT&       back();
     // [string.modifiers], modifiers
+ constexpr basic_string& operator+=(const basic_string& str);
     template<class T>
+ constexpr basic_string& operator+=(const T& t);
+ constexpr basic_string& operator+=(const charT* s);
+ constexpr basic_string& operator+=(charT c);
+ constexpr basic_string& operator+=(initializer_list<charT>);
+    constexpr basic_string& append(const basic_string& str);
+    constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);
+    template<class T>
+      constexpr basic_string& append(const T& t);
+    template<class T>
+      constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);
+    constexpr basic_string& append(const charT* s, size_type n);
+    constexpr basic_string& append(const charT* s);
+    constexpr basic_string& append(size_type n, charT c);
     template<class InputIterator>
+ constexpr basic_string& append(InputIterator first, InputIterator last);
+ constexpr basic_string& append(initializer_list<charT>);
+ constexpr void push_back(charT c);
+    constexpr basic_string& assign(const basic_string& str);
+    constexpr basic_string& assign(basic_string&& str)
       noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
                allocator_traits<Allocator>::is_always_equal::value);
+ constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);
     template<class T>
+ constexpr basic_string& assign(const T& t);
+ template<class T>
+      constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);
+ constexpr basic_string& assign(const charT* s, size_type n);
+    constexpr basic_string& assign(const charT* s);
+    constexpr basic_string& assign(size_type n, charT c);
     template<class InputIterator>
+ constexpr basic_string& assign(InputIterator first, InputIterator last);
+ constexpr basic_string& assign(initializer_list<charT>);
+ constexpr basic_string& insert(size_type pos, const basic_string& str);
+ constexpr basic_string& insert(size_type pos1, const basic_string& str,
                                    size_type pos2, size_type n = npos);
     template<class T>
+ constexpr basic_string& insert(size_type pos, const T& t);
+    template<class T>
+      constexpr basic_string& insert(size_type pos1, const T& t,
                                      size_type pos2, size_type n = npos);
+ constexpr basic_string& insert(size_type pos, const charT* s, size_type n);
+ constexpr basic_string& insert(size_type pos, const charT* s);
+ constexpr basic_string& insert(size_type pos, size_type n, charT c);
+ constexpr iterator insert(const_iterator p, charT c);
+ constexpr iterator insert(const_iterator p, size_type n, charT c);
     template<class InputIterator>
+ constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
+ constexpr iterator insert(const_iterator p, initializer_list<charT>);
+ constexpr basic_string& erase(size_type pos = 0, size_type n = npos);
+ constexpr iterator erase(const_iterator p);
+ constexpr iterator erase(const_iterator first, const_iterator last);
+ constexpr void pop_back();
+ constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
+    constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
                                     size_type pos2, size_type n2 = npos);
     template<class T>
+ constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);
+    template<class T>
+      constexpr basic_string& replace(size_type pos1, size_type n1, const T& t,
                                       size_type pos2, size_type n2 = npos);
+ constexpr basic_string& replace(size_type pos, size_type n1, const charT* s, size_type n2);
+    constexpr basic_string& replace(size_type pos, size_type n1, const charT* s);
+ constexpr basic_string& replace(size_type pos, size_type n1, size_type n2, charT c);
+ constexpr basic_string& replace(const_iterator i1, const_iterator i2,
                                     const basic_string& str);
+ template<class T>
+      constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
+ constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s,
                                     size_type n);
+ constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
+ constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);
     template<class InputIterator>
+ constexpr basic_string& replace(const_iterator i1, const_iterator i2,
                                       InputIterator j1, InputIterator j2);
+ constexpr basic_string& replace(const_iterator, const_iterator, initializer_list<charT>);
+ constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
+    constexpr void swap(basic_string& str)
       noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
                allocator_traits<Allocator>::is_always_equal::value);
     // [string.ops], string operations
+ constexpr const charT* c_str() const noexcept;
+ constexpr const charT* data() const noexcept;
+ constexpr charT* data() noexcept;
+ constexpr operator basic_string_view<charT, traits>() const noexcept;
+ constexpr allocator_type get_allocator() const noexcept;
+ template<class T>
+      constexpr size_type find(const T& t, size_type pos = 0) const noexcept(see below);
+ constexpr size_type find(const basic_string& str, size_type pos = 0) const noexcept;
+ constexpr size_type find(const charT* s, size_type pos, size_type n) const;
+ constexpr size_type find(const charT* s, size_type pos = 0) const;
+ constexpr size_type find(charT c, size_type pos = 0) const noexcept;
+ template<class T>
+      constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(see below);
+ constexpr size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
+ constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
+ constexpr size_type rfind(const charT* s, size_type pos = npos) const;
+ constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
+ template<class T>
+      constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(see below);
+ constexpr size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
+    constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
+ constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
+    constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
+ template<class T>
+      constexpr size_type find_last_of(const T& t,
+ size_type pos = npos) const noexcept(see below);
+    constexpr size_type find_last_of(const basic_string& str,
                                      size_type pos = npos) const noexcept;
+ constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
+    constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
+ constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
+ template<class T>
+      constexpr size_type find_first_not_of(const T& t,
+ size_type pos = 0) const noexcept(see below);
+    constexpr size_type find_first_not_of(const basic_string& str,
                                           size_type pos = 0) const noexcept;
+ constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
+    constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
+ constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
+ template<class T>
+      constexpr size_type find_last_not_of(const T& t,
+ size_type pos = npos) const noexcept(see below);
+ constexpr size_type find_last_not_of(const basic_string& str,
                                          size_type pos = npos) const noexcept;
+ constexpr size_type find_last_not_of(const charT* s, size_type pos, 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;
+ 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;
+    template<class T>
+      constexpr int compare(size_type pos1, size_type n1, const T& t,
                             size_type pos2, size_type n2 = npos) const;
+ constexpr int compare(const basic_string& str) const noexcept;
+ constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
+    constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
                           size_type pos2, size_type n2 = npos) 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<charT, traits> 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<charT, traits> x) const noexcept;
+    constexpr bool ends_with(charT x) const noexcept;
+    constexpr bool ends_with(const charT* x) const;
   };
   template<class InputIterator,
            class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
     basic_string(InputIterator, InputIterator, Allocator = Allocator())
       -> basic_string<typename iterator_traits<InputIterator>::value_type,
                       char_traits<typename iterator_traits<InputIterator>::value_type>,
                       Allocator>;
+  template<class charT,
+           class traits,
+           class Allocator = allocator<charT>>
+    explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
+      -> basic_string<charT, traits, Allocator>;
+  template<class charT,
+           class traits,
+           class Allocator = allocator<charT>>
+    basic_string(basic_string_view<charT, traits>,
+                 typename see below::size_type, typename see below::size_type,
+                 const Allocator& = Allocator())
+      -> basic_string<charT, traits, Allocator>;
 }
 ```
+A `size_type` parameter type in a `basic_string` deduction guide refers
+to the `size_type` member type of the type deduced by the deduction
+guide.
+#### General requirements <a id="string.require">[[string.require]]</a>
 If any operation would cause `size()` to exceed `max_size()`, that
+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*: 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
 `basic_string` sequence may be invalidated by the following uses of that
 `basic_string` object:
+- Passing as an argument to any standard library function taking a
+ reference to non-const `basic_string` as an argument.[^2]
 - Calling non-const member functions, except `operator[]`, `at`, `data`,
   `front`, `back`, `begin`, `rbegin`, `end`, and `rend`.
+#### Constructors and assignment operators <a id="string.cons">[[string.cons]]</a>
 ``` cpp
+constexpr explicit basic_string(const Allocator& a) noexcept;
 ```
+*Ensures:* `size()` is equal to `0`.
 ``` cpp
+constexpr basic_string(const basic_string& str);
+constexpr basic_string(basic_string&& str) noexcept;
 ```
+*Effects:* Constructs an object whose value is that of `str` prior to
+this call.
+*Remarks:* In the second form, `str` is left in a valid but unspecified
+state.
 ``` cpp
+constexpr basic_string(const basic_string& str, size_type pos,
+                       const Allocator& a = Allocator());
+constexpr basic_string(const basic_string& str, size_type pos, size_type n,
                        const Allocator& a = Allocator());
 ```
+*Effects:* Let `n` be `npos` for the first overload. Equivalent to:
 ``` cpp
+basic_string(basic_string_view<charT, traits>(str).substr(pos, n), a)
 ```
 ``` cpp
 template<class T>
+ constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
 ```
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
 *Effects:* Creates a variable, `sv`, as if by
 `basic_string_view<charT, traits> sv = t;` and then behaves the same as:
 ``` cpp
 basic_string(sv.substr(pos, n), a);
 ```
 ``` cpp
+template<class T>
+  constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Creates a variable, `sv`, as if by
+`basic_string_view<charT, traits> sv = t;` and then behaves the same as
+`basic_string(sv.data(), sv.size(), a)`.
 ``` cpp
+constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
 ```
+*Preconditions:* \[`s`, `s + n`) is a valid range.
+*Effects:* Constructs an object whose initial value is the range \[`s`,
+`s + n`).
+*Ensures:* `size()` is equal to `n`, and `traits::compare(data(), s, n)`
+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)`.
 ``` 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
+`c`.
 ``` cpp
 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 indicated in [[container.seq.req]].
 ``` cpp
+constexpr basic_string(initializer_list<charT> il, const Allocator& a = Allocator());
 ```
+*Effects:* Equivalent to `basic_string(il.begin(), il.end(), a)`.
 ``` cpp
+constexpr basic_string(const basic_string& str, const Allocator& alloc);
+constexpr basic_string(basic_string&& str, const Allocator& alloc);
 ```
+*Effects:* Constructs an object whose value is that of `str` prior to
+this call. The stored allocator is constructed from `alloc`. In the
+second form, `str` is left in a valid but unspecified state.
 *Throws:* The second form throws nothing if
 `alloc == str.get_allocator()`.
 ``` cpp
     -> basic_string<typename iterator_traits<InputIterator>::value_type,
                     char_traits<typename iterator_traits<InputIterator>::value_type>,
                     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>>
+  explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
+    -> basic_string<charT, traits, Allocator>;
+template<class charT,
+         class traits,
+         class Allocator = allocator<charT>>
+  basic_string(basic_string_view<charT, traits>,
+               typename see below::size_type, typename see below::size_type,
+               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);
+```
+*Effects:* If `*this` and `str` are the same object, has no effect.
+Otherwise, replaces the value of `*this` with a copy of `str`.
 *Returns:* `*this`.
 ``` cpp
+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>
+  constexpr basic_string& operator=(const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
 ``` cpp
+basic_string_view<charT, traits> sv = t;
+return assign(sv);
 ```
+``` cpp
+constexpr basic_string& operator=(const charT* s);
+```
+*Effects:* Equivalent to:
+`return *this = basic_string_view<charT, traits>(s);`
 ``` cpp
+constexpr basic_string& operator=(charT c);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+return *this = basic_string_view<charT, traits>(addressof(c), 1);
 ```
+``` cpp
+constexpr basic_string& operator=(initializer_list<charT> il);
+```
+*Effects:* Equivalent to:
+``` cpp
+return *this = basic_string_view<charT, traits>(il.begin(), il.size());
+```
+#### Iterator support <a id="string.iterators">[[string.iterators]]</a>
 ``` cpp
+constexpr iterator       begin() noexcept;
+constexpr const_iterator begin() const noexcept;
+constexpr const_iterator cbegin() const noexcept;
 ```
 *Returns:* An iterator referring to the first character in the string.
 ``` cpp
+constexpr iterator       end() noexcept;
+constexpr const_iterator end() const noexcept;
+constexpr const_iterator cend() const noexcept;
 ```
 *Returns:* An iterator which is the past-the-end value.
 ``` cpp
+constexpr reverse_iterator       rbegin() noexcept;
+constexpr const_reverse_iterator rbegin() const noexcept;
+constexpr const_reverse_iterator crbegin() const noexcept;
 ```
 *Returns:* An iterator which is semantically equivalent to
 `reverse_iterator(end())`.
 ``` cpp
+constexpr reverse_iterator       rend() noexcept;
+constexpr const_reverse_iterator rend() const noexcept;
+constexpr const_reverse_iterator crend() const noexcept;
 ```
 *Returns:* An iterator which is semantically equivalent to
 `reverse_iterator(begin())`.
+#### Capacity <a id="string.capacity">[[string.capacity]]</a>
 ``` cpp
+constexpr size_type size() const noexcept;
+constexpr size_type length() const noexcept;
 ```
 *Returns:* A count of the number of char-like objects currently in the
 string.
 *Complexity:* Constant time.
 ``` cpp
+constexpr size_type max_size() const noexcept;
 ```
 *Returns:* The largest possible number of char-like objects that can be
 stored in a `basic_string`.
 *Complexity:* Constant time.
 ``` cpp
+constexpr void resize(size_type n, charT c);
 ```
+*Effects:* Alters the value of `*this` as follows:
+- If `n <= size()`, erases the last `size() - n` elements.
+- If `n > size()`, appends `n - size()` copies of `c`.
 ``` cpp
+constexpr void resize(size_type n);
 ```
+*Effects:* Equivalent to `resize(n, charT())`.
 ``` cpp
+constexpr size_type capacity() const noexcept;
 ```
 *Returns:* The size of the allocated storage in the string.
+*Complexity:* Constant time.
 ``` cpp
+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
+constexpr void shrink_to_fit();
 ```
 *Effects:* `shrink_to_fit` is a non-binding request to reduce
 `capacity()` to `size()`.
+[*Note 1*: The request is non-binding to allow latitude for
 implementation-specific optimizations. — *end note*]
 It does not increase `capacity()`, but may reduce `capacity()` by
 causing reallocation.
+*Complexity:* If the size is not equal to the old capacity, linear in
+the size of the sequence; otherwise constant.
 *Remarks:* Reallocation invalidates all the references, pointers, and
+iterators referring to the elements in the sequence, as well as the
+past-the-end iterator.
+[*Note 2*: If no reallocation happens, they remain
+valid. — *end note*]
 ``` cpp
+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>
 ``` 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.
 *Throws:* Nothing.
 *Complexity:* Constant time.
 ``` cpp
+constexpr const_reference at(size_type pos) const;
+constexpr reference       at(size_type pos);
 ```
 *Throws:* `out_of_range` if `pos >= size()`.
 *Returns:* `operator[](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>
+##### `basic_string::operator+=` <a id="string.op.append">[[string.op.append]]</a>
 ``` cpp
+constexpr basic_string& operator+=(const basic_string& str);
 ```
+*Effects:* Equivalent to: `return append(str);`
 ``` cpp
+template<class T>
+  constexpr basic_string& operator+=(const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
 ``` cpp
+basic_string_view<charT, traits> sv = t;
+return append(sv);
 ```
+``` cpp
+constexpr basic_string& operator+=(const charT* s);
+```
+*Effects:* Equivalent to: `return append(s);`
 ``` cpp
+constexpr basic_string& operator+=(charT c);
 ```
+*Effects:* Equivalent to: `return append(size_type{1}, c);`
 ``` cpp
+constexpr basic_string& operator+=(initializer_list<charT> il);
 ```
+*Effects:* Equivalent to: `return append(il);`
 ##### `basic_string::append` <a id="string.append">[[string.append]]</a>
 ``` cpp
+constexpr basic_string& append(const basic_string& str);
 ```
+*Effects:* Equivalent to: `return append(str.data(), str.size());`
 ``` cpp
+constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+return append(basic_string_view<charT, traits>(str).substr(pos, n));
 ```
 ``` cpp
 template<class T>
+ constexpr basic_string& append(const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+ `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return append(sv.data(), sv.size());
+```
 ``` cpp
+template<class T>
+ constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return append(sv.substr(pos, n));
+```
 ``` cpp
+constexpr basic_string& append(const charT* s, size_type n);
 ```
+*Preconditions:* \[`s`, `s + n`) is a valid range.
+*Effects:* Appends a copy of the range \[`s`, `s + n`) to the string.
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& append(const charT* s);
+```
+*Effects:* Equivalent to: `return append(s, traits::length(s));`
+``` cpp
+constexpr basic_string& append(size_type n, charT c);
 ```
+*Effects:* Appends `n` copies of `c` to the string.
 *Returns:* `*this`.
 ``` cpp
 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
+constexpr basic_string& append(initializer_list<charT> il);
 ```
+*Effects:* Equivalent to: `return append(il.begin(), il.size());`
 ``` cpp
+constexpr void push_back(charT c);
 ```
+*Effects:* Equivalent to `append(size_type{1}, c)`.
 ##### `basic_string::assign` <a id="string.assign">[[string.assign]]</a>
 ``` cpp
+constexpr basic_string& assign(const basic_string& str);
 ```
+*Effects:* Equivalent to: `return *this = str;`
 ``` cpp
+constexpr basic_string& assign(basic_string&& str)
   noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
+*Effects:* Equivalent to: `return *this = std::move(str);`
 ``` cpp
+constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+return assign(basic_string_view<charT, traits>(str).substr(pos, n));
 ```
 ``` cpp
 template<class T>
+ constexpr basic_string& assign(const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+ `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return assign(sv.data(), sv.size());
+```
 ``` cpp
+template<class T>
+  constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return assign(sv.substr(pos, n));
+```
 ``` cpp
+constexpr basic_string& assign(const charT* s, size_type n);
 ```
+*Preconditions:* \[`s`, `s + n`) is a valid range.
+*Effects:* Replaces the string controlled by `*this` with a copy of the
+range \[`s`, `s + n`).
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& assign(const charT* s);
 ```
+*Effects:* Equivalent to: `return assign(s, traits::length(s));`
+``` cpp
+constexpr basic_string& assign(initializer_list<charT> il);
+```
+*Effects:* Equivalent to: `return assign(il.begin(), il.size());`
 ``` cpp
+constexpr basic_string& assign(size_type n, charT c);
 ```
+*Effects:* Equivalent to:
+``` cpp
+clear();
+resize(n, c);
+return *this;
+```
 ``` cpp
 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()));`
 ##### `basic_string::insert` <a id="string.insert">[[string.insert]]</a>
 ``` cpp
+constexpr basic_string& insert(size_type pos, const basic_string& str);
 ```
 *Effects:* Equivalent to: `return insert(pos, str.data(), str.size());`
 ``` cpp
+constexpr basic_string& insert(size_type pos1, const basic_string& str,
                                size_type pos2, size_type n = npos);
 ```
+*Effects:* Equivalent to:
+``` cpp
+return insert(pos1, basic_string_view<charT, traits>(str), pos2, n);
+```
 ``` cpp
+template<class T>
+  constexpr basic_string& insert(size_type pos, const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return insert(pos, sv.data(), sv.size());
+```
 ``` cpp
 template<class T>
+ constexpr basic_string& insert(size_type pos1, const T& t,
                                  size_type pos2, size_type n = npos);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+ `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return insert(pos1, sv.substr(pos2, n));
+```
 ``` cpp
+constexpr basic_string& insert(size_type pos, const charT* s, size_type n);
 ```
+*Preconditions:* \[`s`, `s + n`) is a valid range.
+*Throws:*
+- `out_of_range` if `pos > size()`,
+- `length_error` if `n > max_size() - size()`, or
+- any exceptions thrown by `allocator_traits<Allocator>::allocate`.
+*Effects:* Inserts a copy of the range \[`s`, `s + n`) immediately
+before the character at position `pos` if `pos < size()`, or otherwise
+at the end of the string.
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& insert(size_type pos, const charT* s);
 ```
 *Effects:* Equivalent to: `return insert(pos, s, traits::length(s));`
 ``` cpp
+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
+- any exceptions thrown by `allocator_traits<Allocator>::allocate`.
 ``` cpp
+constexpr iterator insert(const_iterator p, charT c);
 ```
+*Preconditions:* `p` is a valid iterator on `*this`.
+*Effects:* Inserts a copy of `c` at the position `p`.
+*Returns:* An iterator which refers to the inserted character.
 ``` cpp
+constexpr iterator insert(const_iterator p, size_type n, charT c);
 ```
+*Preconditions:* `p` is a valid iterator on `*this`.
+*Effects:* Inserts `n` copies of `c` at the position `p`.
+*Returns:* An iterator which refers to the first inserted character, or
+`p` if `n == 0`.
 ``` cpp
 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()))`.
+*Returns:* An iterator which refers to the first inserted character, or
+`p` if `first == last`.
 ``` cpp
+constexpr iterator insert(const_iterator p, initializer_list<charT> il);
 ```
+*Effects:* Equivalent to: `return insert(p, il.begin(), il.end());`
 ##### `basic_string::erase` <a id="string.erase">[[string.erase]]</a>
 ``` cpp
+constexpr basic_string& erase(size_type pos = 0, size_type n = npos);
 ```
 *Throws:* `out_of_range` if `pos` `> size()`.
 *Effects:* Determines the effective length `xlen` of the string to be
+removed as the smaller of `n` and `size() - pos`. Removes the characters
+in the range \[`begin() + pos`, `begin() + pos + xlen`).
 *Returns:* `*this`.
 ``` cpp
+constexpr iterator erase(const_iterator p);
 ```
+*Preconditions:* `p` is a valid dereferenceable iterator on `*this`.
 *Throws:* Nothing.
 *Effects:* Removes the character referred to by `p`.
 *Returns:* An iterator which points to the element immediately following
 `p` prior to the element being erased. If no such element exists,
 `end()` is returned.
 ``` cpp
+constexpr iterator erase(const_iterator first, const_iterator last);
 ```
+*Preconditions:* `first` and `last` are valid iterators on `*this`.
+\[`first`, `last`) is a valid range.
 *Throws:* Nothing.
 *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();
 ```
+*Preconditions:* `!empty()`.
 *Throws:* Nothing.
+*Effects:* Equivalent to `erase(end() - 1)`.
 ##### `basic_string::replace` <a id="string.replace">[[string.replace]]</a>
 ``` cpp
+constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
 ```
 *Effects:* Equivalent to:
 `return replace(pos1, n1, str.data(), str.size());`
 ``` cpp
+constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
                                 size_type pos2, size_type n2 = npos);
 ```
+*Effects:* Equivalent to:
+``` cpp
+return replace(pos1, n1, basic_string_view<charT, traits>(str).substr(pos2, n2));
+```
 ``` cpp
+template<class T>
+  constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
 *Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return replace(pos1, n1, sv.data(), sv.size());
+```
 ``` cpp
 template<class T>
+ constexpr basic_string& replace(size_type pos1, size_type n1, const T& t,
                                   size_type pos2, size_type n2 = npos);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+ `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return replace(pos1, n1, sv.substr(pos2, n2));
+```
 ``` cpp
+constexpr basic_string& replace(size_type pos1, size_type n1, const charT* s, size_type n2);
 ```
+*Preconditions:* \[`s`, `s + n2`) is a valid range.
+*Throws:*
+- `out_of_range` if `pos1 > size()`,
+- `length_error` if the length of the resulting string would exceed
+  `max_size()` (see below), or
+- any exceptions thrown by `allocator_traits<Allocator>::allocate`.
 *Effects:* Determines the effective length `xlen` of the string to be
 removed as the smaller of `n1` and `size() - pos1`. If
 `size() - xlen >= max_size() - n2` throws `length_error`. Otherwise, the
+function replaces the characters in the range \[`begin() + pos1`,
+`begin() + pos1 + xlen`) with a copy of the range \[`s`, `s + n2`).
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& replace(size_type pos, size_type n, const charT* s);
 ```
 *Effects:* Equivalent to:
 `return replace(pos, n, s, traits::length(s));`
 ``` cpp
+constexpr basic_string& replace(size_type pos1, size_type n1, size_type n2, charT c);
 ```
+*Throws:*
+- `out_of_range` if `pos1 > size()`,
+- `length_error` if the length of the resulting string would exceed
+  `max_size()` (see below), or
+- any exceptions thrown by `allocator_traits<Allocator>::allocate.`
+*Effects:* Determines the effective length `xlen` of the string to be
+removed as the smaller of `n1` and `size() - pos1`. If
+`size() - xlen >=` `max_size() - n2` throws `length_error`. Otherwise,
+the function replaces the characters in the range \[`begin() + pos1`,
+`begin() + pos1 + xlen`) with `n2` copies of `c`.
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
 ```
+*Effects:* Equivalent to:
+`return replace(i1, i2, basic_string_view<charT, traits>(str));`
 ``` cpp
+template<class T>
+  constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Preconditions:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
+*Effects:* Equivalent to:
 ``` cpp
+basic_string_view<charT, traits> sv = t;
+return replace(i1 - begin(), i2 - i1, sv.data(), sv.size());
 ```
 ``` cpp
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
 ```
+*Effects:* Equivalent to:
+`return replace(i1, i2, basic_string_view<charT, traits>(s, n));`
+``` cpp
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
+```
+*Effects:* Equivalent to:
+`return replace(i1, i2, basic_string_view<charT, traits>(s));`
 ``` cpp
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);
 ```
+*Preconditions:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
+*Effects:* Equivalent to: `return replace(i1 - begin(), i2 - i1, n, c);`
 ``` cpp
 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
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il);
 ```
+*Effects:* Equivalent to:
+`return replace(i1, i2, il.begin(), il.size());`
 ##### `basic_string::copy` <a id="string.copy">[[string.copy]]</a>
 ``` cpp
+constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
 ```
+*Effects:* Equivalent to:
+`return basic_string_view<charT, traits>(*this).copy(s, n, pos);`
 [*Note 1*: This does not terminate `s` with a null
 object. — *end note*]
 ##### `basic_string::swap` <a id="string.swap">[[string.swap]]</a>
 ``` cpp
+constexpr void swap(basic_string& s)
   noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
+*Preconditions:*
+`allocator_traits<Allocator>::propagate_on_container_swap::value` is
+`true` or `get_allocator() == s.get_allocator()`.
+*Ensures:* `*this` contains the same sequence of characters that was in
+`s`, `s` contains the same sequence of characters that was in `*this`.
 *Throws:* Nothing.
 *Complexity:* Constant time.
+#### String operations <a id="string.ops">[[string.ops]]</a>
+##### Accessors <a id="string.accessors">[[string.accessors]]</a>
 ``` cpp
+constexpr const charT* c_str() const noexcept;
+constexpr const charT* data() const noexcept;
 ```
+*Returns:* A pointer `p` such that `p + i == addressof(operator[](i))`
+for each `i` in \[`0`, `size()`\].
 *Complexity:* Constant time.
+*Remarks:* The program shall not modify any of the values stored in the
+character array; otherwise, the behavior is undefined.
 ``` cpp
+constexpr charT* data() noexcept;
 ```
+*Returns:* A pointer `p` such that `p + i == addressof(operator[](i))`
+for each `i` in \[`0`, `size()`\].
 *Complexity:* Constant time.
+*Remarks:* The program shall not modify the value stored at `p + size()`
+to any value other than `charT()`; otherwise, the behavior is undefined.
 ``` cpp
+constexpr operator basic_string_view<charT, traits>() const noexcept;
 ```
 *Effects:* Equivalent to:
 `return basic_string_view<charT, traits>(data(), size());`
 ``` cpp
+constexpr allocator_type get_allocator() const noexcept;
 ```
 *Returns:* A copy of the `Allocator` object used to construct the string
 or, if that allocator has been replaced, a copy of the most recent
 replacement.
+##### Searching <a id="string.find">[[string.find]]</a>
+Let *F* be one of `find`, `rfind`, `find_first_of`, `find_last_of`,
+`find_first_not_of`, and `find_last_not_of`.
+- Each member function of the form
   ``` cpp
+  constexpr size_type F(const basic_string& str, size_type pos) const noexcept;
   ```
+  has effects equivalent to:
+  `return F(basic_string_view<charT, traits>(str), pos);`
+- Each member function of the form
   ``` cpp
+  constexpr size_type F(const charT* s, size_type pos) const;
   ```
+  has effects equivalent to:
+  `return F(basic_string_view<charT, traits>(s), pos);`
+- Each member function of the form
   ``` cpp
+  constexpr size_type F(const charT* s, size_type pos, size_type n) const;
   ```
+  has effects equivalent to:
+  `return F(basic_string_view<charT, traits>(s, n), pos);`
+- Each member function of the form
   ``` cpp
+  constexpr size_type F(charT c, size_type pos) const noexcept;
   ```
+  has effects equivalent to:
   ``` cpp
+  return F(basic_string_view<charT, traits>(addressof(c), 1), pos);
   ```
 ``` cpp
+template<class T>
+  constexpr size_type find(const T& t, size_type pos = 0) const noexcept(see below);
+template<class T>
+  constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(see below);
+template<class T>
+  constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(see below);
+template<class T>
+  constexpr size_type find_last_of(const T& t, size_type pos = npos) const noexcept(see below);
+template<class T>
+  constexpr size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept(see below);
+template<class T>
+  constexpr size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept(see below);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+ `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Let *G* be the name of the function. Equivalent to:
 ``` cpp
+basic_string_view<charT, traits> s = *this, sv = t;
+return s.G(sv, pos);
 ```
+*Remarks:* The expression inside `noexcept` is equivalent to
+`is_nothrow_convertible_v<const T&, basic_string_view<charT, traits>>`.
 ##### `basic_string::substr` <a id="string.substr">[[string.substr]]</a>
 ``` cpp
+constexpr basic_string substr(size_type pos = 0, size_type n = npos) const;
 ```
 *Throws:* `out_of_range` if `pos > size()`.
 *Effects:* Determines the effective length `rlen` of the string to copy
 *Returns:* `basic_string(data()+pos, rlen)`.
 ##### `basic_string::compare` <a id="string.compare">[[string.compare]]</a>
 ``` cpp
+template<class T>
+  constexpr int compare(const T& t) const noexcept(see below);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+`return basic_string_view<charT, traits>(*this).compare(t);`
+*Remarks:* The expression inside `noexcept` is equivalent to
+`is_nothrow_convertible_v<const T&, basic_string_view<charT, traits>>`.
 ``` cpp
+template<class T>
+  constexpr int compare(size_type pos1, size_type n1, const T& t) const;
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
 *Effects:* Equivalent to:
 ``` cpp
+return basic_string_view<charT, traits>(*this).substr(pos1, n1).compare(t);
 ```
 ``` cpp
 template<class T>
+ constexpr int compare(size_type pos1, size_type n1, const T& t,
                         size_type pos2, size_type n2 = npos) const;
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
 *Effects:* Equivalent to:
 ``` cpp
+basic_string_view<charT, traits> s = *this, sv = t;
+return s.substr(pos1, n1).compare(sv.substr(pos2, n2));
 ```
 ``` cpp
+constexpr int compare(const basic_string& str) const noexcept;
 ```
 *Effects:* Equivalent to:
 `return compare(basic_string_view<charT, traits>(str));`
 ``` cpp
+constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
 ```
 *Effects:* Equivalent to:
 `return compare(pos1, n1, basic_string_view<charT, traits>(str));`
 ``` cpp
+constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
                       size_type pos2, size_type n2 = npos) const;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return compare(pos1, n1, basic_string_view<charT, traits>(str), pos2, n2);
 ```
 ``` cpp
+constexpr int compare(const charT* s) const;
 ```
+*Effects:* Equivalent to:
+`return compare(basic_string_view<charT, traits>(s));`
 ``` cpp
+constexpr int compare(size_type pos, size_type n1, const charT* s) const;
 ```
+*Effects:* Equivalent to:
+`return compare(pos, n1, basic_string_view<charT, traits>(s));`
 ``` cpp
+constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
 ```
+*Effects:* Equivalent to:
+`return compare(pos, n1, basic_string_view<charT, traits>(s, n2));`
+##### `basic_string::starts_with` <a id="string.starts.with">[[string.starts.with]]</a>
+``` cpp
+constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
+constexpr bool starts_with(charT x) const noexcept;
+constexpr bool starts_with(const charT* x) const;
+```
+*Effects:* Equivalent to:
+``` cpp
+return basic_string_view<charT, traits>(data(), size()).starts_with(x);
+```
+##### `basic_string::ends_with` <a id="string.ends.with">[[string.ends.with]]</a>
+``` cpp
+constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
+constexpr bool ends_with(charT x) const noexcept;
+constexpr bool ends_with(const charT* x) const;
+```
+*Effects:* Equivalent to:
+``` cpp
+return basic_string_view<charT, traits>(data(), size()).ends_with(x);
+```

Diff to HTML by rtfpessoa