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

Files changed (1) hide show

tmp/tmp_q63mond/{from.md → to.md} +537 -641

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

@@ -1,6 +1,6 @@
-## Class template `basic_string` <a id="basic.string">[[basic.string]]</a>
 The class template `basic_string` describes objects that can store a
 sequence consisting of a varying number of arbitrary char-like objects
 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
@@ -10,12 +10,12 @@ char-like objects held in a `basic_string` object is designated by
 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]
-The iterators supported by `basic_string` are random access iterators (
-[[random.access.iterators]]).
 In all cases, `size() <= capacity()`.
 The functions described in this Clause can report two kinds of errors,
 each associated with an exception type:
@@ -30,33 +30,39 @@ namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
   class basic_string {
   public:
     // types:
- typedef          traits                                         traits_type;
- typedef typename traits::char_type                              value_type;
- typedef          Allocator                                      allocator_type;
- typedef typename allocator_traits<Allocator>::size_type         size_type;
- typedef typename allocator_traits<Allocator>::difference_type   difference_type;
- typedef value_type& reference;
- typedef const value_type&   const_reference;
- typedef typename allocator_traits<Allocator>::pointer           pointer;
- typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
-    typedef implementation-defined              iterator;       // See [container.requirements]
-    typedef implementation-defined              const_iterator; // See [container.requirements]
-    typedef std::reverse_iterator<iterator> reverse_iterator;
-    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     static const size_type npos  = -1;
-    // [string.cons], construct/copy/destroy:
-    basic_string() : basic_string(Allocator()) { }
-    explicit basic_string(const Allocator& a);
     basic_string(const basic_string& str);
     basic_string(basic_string&& str) noexcept;
-    basic_string(const basic_string& str, size_type pos, size_type n = npos,
                           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());
@@ -67,16 +73,19 @@ namespace std {
     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;
     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;
@@ -88,11 +97,11 @@ namespace std {
     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);
@@ -100,51 +109,64 @@ namespace std {
     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+=(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(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;
     basic_string& assign(const basic_string& str, 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 pos1, 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, 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);
@@ -161,18 +183,25 @@ namespace std {
     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 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, 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);
@@ -180,54 +209,76 @@ namespace std {
       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);
-    // [string.ops], string operations:
     const charT* c_str() const noexcept;
     const charT* data() const noexcept;
     allocator_type get_allocator() 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(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(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 (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(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 (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(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,
@@ -236,14 +287,21 @@ namespace std {
     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;
   };
 }
 ```
-### `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
@@ -253,30 +311,28 @@ 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]].
-The char-like objects in a `basic_string` object shall be stored
-contiguously. That is, for any `basic_string` object `s`, the identity
-`&*(s.begin() + n) == &*s.begin() + n` shall hold for all values of `n`
-such that `0 <= n < s.size()`.
 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`,
   `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);
 ```
 *Effects:* Constructs an object of class `basic_string`. The
 postconditions of this function are indicated in
 Table  [[tab:strings.ctr.1]].
@@ -305,32 +361,65 @@ valid state with an unspecified 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, size_type n = npos,
              const Allocator& a = Allocator());
 ```
-*Requires:* `pos <= str.size()`
 *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, 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
 basic_string(const charT* s, size_type n,
              const Allocator& a = Allocator());
 ```
@@ -367,18 +456,15 @@ indicated in Table  [[tab:strings.ctr.4]].
 | ------------ | ------------------------------------------------------------------------------------------------------ |
 | `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()`                                                                  |
-*Remarks:* Uses `traits::length()`.
 ``` 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]].
@@ -394,14 +480,14 @@ its initial string value by repeating the char-like object `c` for all
 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]]).
@@ -420,11 +506,11 @@ 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&)` 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()`. |
@@ -434,48 +520,60 @@ unspecified value.
 *Throws:* The second form throws nothing if
 `alloc == str.get_allocator()`.
 ``` 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;
 ```
-*Effects:* If `*this` and `str` are not the same object, modifies
-`*this` as shown in Table  [[tab:strings.op=rv]]. A valid implementation
-is `swap(str)`.
-If `*this` and `str` are the same object, the member has no effect.
-*Returns:* `*this`
-**Table: `operator=(basic_string&&)` effects** <a id="tab:strings.op=rv">[tab:strings.op=rv]</a>
-| Element      | Value                                                                  |
-| ------------ | ---------------------------------------------------------------------- |
-| `data()`     | points at the array whose first element was pointed at by `str.data()` |
-| `size()`     | previous value of `str.size()`                                         |
-| `capacity()` | a value at least as large as `size()`                                  |
 ``` cpp
 basic_string& operator=(const charT* s);
 ```
@@ -491,15 +589,15 @@ basic_string& operator=(charT c);
 ``` cpp
 basic_string& operator=(initializer_list<charT> il);
 ```
-*Effects:* `*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;
@@ -531,11 +629,11 @@ 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;
 ```
@@ -552,20 +650,19 @@ size_type length() const noexcept;
 ``` cpp
 size_type max_size() const noexcept;
 ```
-*Returns:* The size of the largest possible string.
 *Complexity:* Constant time.
 ``` cpp
 void resize(size_type n, charT c);
 ```
-*Requires:* `n <= max_size()`
 *Throws:* `length_error` if `n > max_size()`.
 *Effects:* Alters the length of the string designated by `*this` as
 follows:
@@ -579,11 +676,11 @@ follows:
 ``` cpp
 void resize(size_type n);
 ```
-*Effects:* `resize(n,charT())`.
 ``` cpp
 size_type capacity() const noexcept;
 ```
@@ -596,24 +693,37 @@ 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`. 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.
 *Throws:* `length_error` if `res_arg > max_size()`.[^4]
 ``` cpp
 void shrink_to_fit();
 ```
-*Remarks:* `shrink_to_fit` is a non-binding request to reduce
-`capacity()` to `size()`. The request is non-binding to allow latitude
-for implementation-specific optimizations.
 ``` cpp
 void clear() noexcept;
 ```
@@ -627,22 +737,23 @@ erase(begin(), end());
 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 leads to undefined behavior.
 *Throws:* Nothing.
 *Complexity:* Constant time.
@@ -658,36 +769,44 @@ reference       at(size_type pos);
 ``` cpp
 const charT& front() const;
 charT& front();
 ```
-*Requires:* `!empty()`
-*Effects:* Equivalent to `operator[](0)`.
 ``` cpp
 const charT& back() const;
 charT& back();
 ```
-*Requires:* `!empty()`
-*Effects:* Equivalent to `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+=(const charT* s);
 ```
 *Effects:* Calls `append(s)`.
@@ -708,11 +827,11 @@ 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);
 ```
@@ -724,20 +843,42 @@ basic_string&
 ``` cpp
 basic_string&
   append(const basic_string& str, size_type pos, size_type n = npos);
 ```
-*Requires:* `pos <= str.size()`
 *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(const charT* s, size_type n);
 ```
@@ -776,11 +917,12 @@ 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))`.
 *Returns:* `*this`.
 ``` cpp
 basic_string& append(initializer_list<charT> il);
@@ -794,43 +936,65 @@ basic_string& append(initializer_list<charT> il);
 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 `assign(str, 0, npos)`.
 *Returns:* `*this`.
 ``` cpp
-basic_string& assign(basic_string&& str) noexcept;
 ```
-*Effects:* The function replaces the string controlled by `*this` with a
-string of length `str.size()` whose elements are a copy of the string
-controlled by `str`. A valid implementation is `swap(str)`.
 *Returns:* `*this`.
 ``` cpp
 basic_string&
   assign(const basic_string& str, size_type pos,
          size_type n = npos);
 ```
-*Requires:* `pos <= str.size()`
 *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(const charT* s, size_type n);
@@ -875,54 +1039,71 @@ basic_string& assign(size_type n, charT c);
 ``` cpp
 template<class InputIterator>
   basic_string& assign(InputIterator first, InputIterator last);
 ```
-*Effects:* Equivalent to `assign(basic_string(first, last))`.
 *Returns:* `*this`.
-#### `basic_string::insert` <a id="string::insert">[[string::insert]]</a>
 ``` cpp
 basic_string&
-  insert(size_type pos1,
          const basic_string& str);
 ```
-*Requires:* `pos <= size()`.
-*Throws:* `out_of_range` if `pos > size()`.
-*Effects:* Calls `insert(pos, str.data(), str.size())`.
-*Returns:* `*this`.
 ``` cpp
 basic_string&
   insert(size_type pos1,
          const basic_string& str,
          size_type pos2, size_type n = npos);
 ```
-*Requires:* `pos1 <= size()` and `pos2 <= str.size()`
 *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, const charT* s, size_type n);
 ```
-*Requires:* `s` points to an array of at least `n` elements of `charT`
-and `pos <= size()`.
 *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
@@ -937,16 +1118,14 @@ by `*this`.
 ``` cpp
 basic_string&
   insert(size_type pos, const charT* s);
 ```
-*Requires:* `pos <= size()` and `s` points to an array of at least
-`traits::length(s) + 1` elements of `charT`.
-*Effects:* Equivalent to `insert(pos, s, traits::length(s))`.
-*Returns:* `*this`.
 ``` cpp
 basic_string&
   insert(size_type pos, size_type n, charT c);
 ```
@@ -959,11 +1138,11 @@ basic_string&
 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.
@@ -971,11 +1150,11 @@ character.
 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`.
@@ -986,32 +1165,30 @@ template<class InputIterator>
 *Requires:* `p` is a valid iterator on `*this`. `[first, last)` is a
 valid range.
 *Effects:* Equivalent to
-`insert(p - begin(), basic_string(first, last))`.
 *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:* `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);
 ```
-*Requires:* `pos` ` <= size()`
 *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`.
@@ -1027,11 +1204,11 @@ string controlled by `*this` beginning at position `pos + xlen`.
 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.
@@ -1042,66 +1219,86 @@ 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);
 ```
-*Requires:* `pos1 <= size()`.
-*Throws:* `out_of_range` if `pos1 > size()`.
-*Effects:* Calls `replace(pos1, n1, str.data(), str.size())`.
-*Returns:* `*this`.
 ``` cpp
 basic_string&
   replace(size_type pos1, size_type n1,
           const basic_string& str,
           size_type pos2, size_type n2 = npos);
 ```
-*Requires:* `pos1 <= size()` and `pos2 <= str.size()`.
 *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, const charT* s, size_type n2);
 ```
-*Requires:* `pos1 <= size()` and `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
@@ -1119,16 +1316,15 @@ string controlled by `*this` beginning at position `pos + xlen`.
 ``` cpp
 basic_string&
   replace(size_type pos, size_type n, const charT* s);
 ```
-*Requires:* `pos <= size()` and `s` points to an array of at least
-`traits::length(s) + 1` elements of `charT`.
-*Effects:* Calls `replace(pos, n, s, traits::length(s))`.
-*Returns:* `*this`.
 ``` cpp
 basic_string&
   replace(size_type pos1, size_type n1,
           size_type n2, charT c);
@@ -1146,10 +1342,21 @@ basic_string& replace(const_iterator i1, const_iterator i2, const basic_string&
 *Effects:* Calls `replace(i1 - begin(), i2 - i1, str)`.
 *Returns:* `*this`.
 ``` cpp
 basic_string&
   replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
 ```
@@ -1190,11 +1397,12 @@ template<class InputIterator>
 ```
 *Requires:* \[`begin()`, `i1`), \[`i1`, `i2`) and \[`j1`, `j2`) are
 valid ranges.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, basic_string(j1, j2))`.
 *Returns:* `*this`.
 ``` cpp
 basic_string& replace(const_iterator i1, const_iterator i2,
@@ -1206,49 +1414,48 @@ basic_string& replace(const_iterator i1, const_iterator i2,
 *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;
 ```
-*Requires:* `pos <= size()`
 *Throws:* `out_of_range` if `pos > size()`.
-*Effects:* Determines the effective length `rlen` of the string to copy
-as the smaller of `n` and `size() - pos`. `s` shall designate an array
-of at least `rlen` elements.
-The function then replaces the string designated by `s` with a string of
-length `rlen` whose elements are a copy of the string controlled by
-`*this` beginning at position `pos`.
-The function does not append a null object to the string designated by
-`s`.
 *Returns:* `rlen`.
-#### `basic_string::swap` <a id="string::swap">[[string::swap]]</a>
 ``` cpp
-void swap(basic_string& s);
 ```
-`*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;
 ```
@@ -1259,726 +1466,415 @@ const charT* data() const noexcept;
 *Complexity:* Constant time.
 *Requires:* The program shall not alter any of the values stored in the
 character array.
 ``` 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(const basic_string& str,
-               size_type pos = 0) const noexcept;
 ```
 *Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions obtain:
-- `pos <= xpos` and `xpos + str.size() <= size()`;
-- `traits::eq(at(xpos+I), str.at(I))` for all elements `I` of the string
- controlled by `str`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
-*Remarks:* Uses `traits::eq()`.
 ``` cpp
 size_type find(const charT* s, size_type pos, size_type n) const;
 ```
-*Returns:* `find(basic_string(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(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(const basic_string& str,
-                size_type pos = npos) const noexcept;
 ```
 *Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions obtain:
-- `xpos <= pos` and `xpos + str.size() <= size()`;
-- `traits::eq(at(xpos+I), str.at(I))` for all elements `I` of the string
- controlled by `str`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
-*Remarks:* Uses `traits::eq()`.
 ``` cpp
 size_type rfind(const charT* s, size_type pos, size_type n) const;
 ```
-*Returns:* `rfind(basic_string(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(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(const basic_string& str,
-                size_type pos = 0) const noexcept;
 ```
 *Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions obtain:
 - `pos <= xpos` and `xpos < size()`;
-- `traits::eq(at(xpos), str.at(I))` for some element `I` of the string
- controlled by `str`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
-*Remarks:* Uses `traits::eq()`.
 ``` cpp
-size_type
-  find_first_of(const charT* s, size_type pos, size_type n) const;
 ```
-*Returns:* `find_first_of(basic_string(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(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(const basic_string& str,
-               size_type pos = npos) const noexcept;
 ```
 *Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions obtain:
 - `xpos <= pos` and `xpos < size()`;
-- `traits::eq(at(xpos), str.at(I))` for some element `I` of the string
- controlled by `str`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
-*Remarks:* Uses `traits::eq()`.
 ``` cpp
 size_type find_last_of(const charT* s, size_type pos, size_type n) const;
 ```
-*Returns:* `find_last_of(basic_string(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(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(const basic_string& str,
                             size_type pos = 0) const noexcept;
 ```
 *Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions obtain:
 - `pos <= xpos` and `xpos < size()`;
-- `traits::eq(at(xpos), str.at(I))` for no element `I` of the string
- controlled by `str`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
-*Remarks:* Uses `traits::eq()`.
 ``` cpp
-size_type
-  find_first_not_of(const charT* s, size_type pos, size_type n) const;
 ```
-*Returns:* `find_first_not_of(basic_string(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(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(const basic_string& str,
                            size_type pos = npos) const noexcept;
 ```
 *Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions obtain:
 - `xpos <= pos` and `xpos < size()`;
-- `traits::eq(at(xpos), str.at(I))` for no element `I` of the string
- controlled by `str`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
-*Remarks:* Uses `traits::eq()`.
 ``` cpp
-size_type find_last_not_of(const charT* s, size_type pos,
-                           size_type n) const;
 ```
-*Returns:* `find_last_not_of(basic_string(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(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;
 ```
-*Requires:* `pos <= size()`
 *Throws:* `out_of_range` if `pos > size()`.
 *Effects:* Determines the effective length `rlen` of the string to copy
 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(const basic_string& str) const noexcept;
 ```
-*Effects:* Determines the effective length *rlen* of the strings to
-compare as the smallest of `size()` and `str.size()`. The function then
 compares the two strings by calling
-`traits::compare(data(), str.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() <  str.size()` | `< 0`        |
-| `size() == str.size()` | `  0`        |
-| `size() >  str.size()` | `> 0`        |
 ``` cpp
-int compare(size_type pos1, size_type n1,
-            const basic_string& str) const;
 ```
-*Returns:* `basic_string(*this,pos1,n1).compare(str)`.
 ``` cpp
 int compare(size_type pos1, size_type n1,
             const basic_string& str,
             size_type pos2, size_type n2 = npos) const;
 ```
-*Returns:*
-`basic_string(*this, pos1, n1).compare(basic_string(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))`.
-### `basic_string` non-member functions <a id="string.nonmembers">[[string.nonmembers]]</a>
-#### `operator+` <a id="string::op+">[[string::op+]]</a>
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>
-    operator+(const basic_string<charT,traits,Allocator>& lhs,
-              const basic_string<charT,traits,Allocator>& rhs);
-```
-*Returns:* `basic_string<charT,traits,Allocator>(lhs).append(rhs)`
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>
-    operator+(basic_string<charT,traits,Allocator>&& lhs,
-              const basic_string<charT,traits,Allocator>& rhs);
-```
-*Returns:* `std::move(lhs.append(rhs))`
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>
-    operator+(const basic_string<charT,traits,Allocator>& lhs,
-              basic_string<charT,traits,Allocator>&& rhs);
-```
-*Returns:* `std::move(rhs.insert(0, lhs))`
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>
-    operator+(basic_string<charT,traits,Allocator>&& lhs,
-              basic_string<charT,traits,Allocator>&& rhs);
-```
-*Returns:* `std::move(lhs.append(rhs))` Or equivalently
-`std::move(rhs.insert(0, lhs))`
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>
-    operator+(const charT* lhs,
-              const basic_string<charT,traits,Allocator>& rhs);
-```
-*Returns:* `basic_string<charT,traits,Allocator>(lhs) + rhs`.
-*Remarks:* Uses `traits::length()`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>
-    operator+(const charT* lhs,
-              basic_string<charT,traits,Allocator>&& rhs);
-```
-*Returns:* `std::move(rhs.insert(0, lhs))`.
-*Remarks:* Uses `traits::length()`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>
-    operator+(charT lhs,
-              const basic_string<charT,traits,Allocator>& rhs);
-```
-*Returns:* `basic_string<charT,traits,Allocator>(1,lhs) + rhs`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>
-    operator+(charT lhs,
-              basic_string<charT,traits,Allocator>&& rhs);
-```
-*Returns:* `std::move(rhs.insert(0, 1, lhs))`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>
-    operator+(const basic_string<charT,traits,Allocator>& lhs,
-              const charT* rhs);
-```
-*Returns:* `lhs + basic_string<charT,traits,Allocator>(rhs)`.
-*Remarks:* Uses `traits::length()`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>
-    operator+(basic_string<charT,traits,Allocator>&& lhs,
-              const charT* rhs);
-```
-*Returns:* `std::move(lhs.append(rhs))`.
-*Remarks:* Uses `traits::length()`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>
-    operator+(const basic_string<charT,traits,Allocator>& lhs,
-              charT rhs);
-```
-*Returns:* `lhs + basic_string<charT,traits,Allocator>(1,rhs)`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>
-    operator+(basic_string<charT,traits,Allocator>&& lhs,
-              charT rhs);
-```
-*Returns:* `std::move(lhs.append(1, rhs))`.
-#### `operator==` <a id="string::operator==">[[string::operator==]]</a>
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator==(const basic_string<charT,traits,Allocator>& lhs,
-                  const basic_string<charT,traits,Allocator>& rhs) noexcept;
-```
-*Returns:* `lhs.compare(rhs) == 0`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator==(const charT* lhs,
-                  const basic_string<charT,traits,Allocator>& rhs);
-```
-*Returns:* `rhs == lhs`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator==(const basic_string<charT,traits,Allocator>& lhs,
-                  const charT* rhs);
-```
-*Requires:* `rhs` points to an array of at least
-`traits::length(rhs) + 1` elements of `charT`.
-*Returns:* `lhs.compare(rhs) == 0`.
-#### `operator!=` <a id="string::op!=">[[string::op!=]]</a>
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
-                  const basic_string<charT,traits,Allocator>& rhs) noexcept;
-```
-*Returns:* `!(lhs == rhs)`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator!=(const charT* lhs,
-                  const basic_string<charT,traits,Allocator>& rhs);
-```
-*Returns:* `rhs != lhs`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
-                  const charT* rhs);
-```
-*Requires:* `rhs` points to an array of at least
-`traits::length(rhs) + 1` elements of `charT`.
-*Returns:* `lhs.compare(rhs) != 0`.
-#### `operator<` <a id="string::op<">[[string::op<]]</a>
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator< (const basic_string<charT,traits,Allocator>& lhs,
-                  const basic_string<charT,traits,Allocator>& rhs) noexcept;
-```
-*Returns:* `lhs.compare(rhs) < 0`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator< (const charT* lhs,
-                  const basic_string<charT,traits,Allocator>& rhs);
-```
-*Returns:* `rhs.compare(lhs) > 0`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator< (const basic_string<charT,traits,Allocator>& lhs,
-                  const charT* rhs);
-```
-*Returns:* `lhs.compare(rhs) < 0`.
-#### `operator>` <a id="string::op>">[[string::op>]]</a>
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator> (const basic_string<charT,traits,Allocator>& lhs,
-                  const basic_string<charT,traits,Allocator>& rhs) noexcept;
-```
-*Returns:* `lhs.compare(rhs) > 0`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator> (const charT* lhs,
-                  const basic_string<charT,traits,Allocator>& rhs);
-```
-*Returns:* `rhs.compare(lhs) < 0`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator> (const basic_string<charT,traits,Allocator>& lhs,
-                  const charT* rhs);
-```
-*Returns:* `lhs.compare(rhs) > 0`.
-#### `operator<=` <a id="string::op<=">[[string::op<=]]</a>
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator<=(const basic_string<charT,traits,Allocator>& lhs,
-                  const basic_string<charT,traits,Allocator>& rhs) noexcept;
-```
-*Returns:* `lhs.compare(rhs) <= 0`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator<=(const charT* lhs,
-                  const basic_string<charT,traits,Allocator>& rhs);
-```
-*Returns:* `rhs.compare(lhs) >= 0`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator<=(const basic_string<charT,traits,Allocator>& lhs,
-                  const charT* rhs);
-```
-*Returns:* `lhs.compare(rhs) <= 0`.
-#### `operator>=` <a id="string::op>=">[[string::op>=]]</a>
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator>=(const basic_string<charT,traits,Allocator>& lhs,
-                  const basic_string<charT,traits,Allocator>& rhs) noexcept;
-```
-*Returns:* `lhs.compare(rhs) >= 0`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator>=(const charT* lhs,
-                  const basic_string<charT,traits,Allocator>& rhs);
-```
-*Returns:* `rhs.compare(lhs) <= 0`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  bool operator>=(const basic_string<charT,traits,Allocator>& lhs,
-                  const charT* rhs);
-```
-*Returns:* `lhs.compare(rhs) >= 0`.
-#### `swap` <a id="string.special">[[string.special]]</a>
-``` cpp
-template<class charT, class traits, class Allocator>
-  void swap(basic_string<charT,traits,Allocator>& lhs,
-    basic_string<charT,traits,Allocator>& rhs);
-```
-*Effects:* Equivalent to `lhs.swap(rhs);`
-#### Inserters and extractors <a id="string.io">[[string.io]]</a>
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_istream<charT,traits>&
-    operator>>(basic_istream<charT,traits>& is,
-               basic_string<charT,traits,Allocator>& str);
-```
-*Effects:* Behaves as a formatted input
-function ([[istream.formatted.reqmts]]). After constructing a `sentry`
-object, if the sentry converts to true, calls `str.erase()` and then
-extracts characters from `is` and appends them to `str` as if by calling
-`str.append(1,c)`. If `is.width()` is greater than zero, the maximum
-number `n` of characters appended is `is.width()`; otherwise `n` is
-`str.max_size()`. Characters are extracted and appended until any of the
-following occurs:
-- *n* characters are stored;
-- end-of-file occurs on the input sequence;
-- `isspace(c,is.getloc())` is true for the next available input
-  character *c*.
-After the last character (if any) is extracted, `is.width(0)` is called
-and the `sentry` object `k` is destroyed.
-If the function extracts no characters, it calls
-`is.setstate(ios::failbit)`, which may throw
-`ios_base::failure` ([[iostate.flags]]).
-*Returns:* `is`
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_ostream<charT, traits>&
-    operator<<(basic_ostream<charT, traits>& os,
-               const basic_string<charT,traits,Allocator>& str);
-```
-*Effects:* Behaves as a formatted output
-function ([[ostream.formatted.reqmts]]) of `os`. Forms a character
-sequence `seq`, initially consisting of the elements defined by the
-range \[`str.begin(), str.end()`). Determines padding for `seq` as
-described in  [[ostream.formatted.reqmts]]. Then inserts `seq` as if by
-calling `os.rdbuf()->sputn(seq, n)`, where `n` is the larger of
-`os.width()` and `str.size()`; then calls `os.width(0)`.
-*Returns:* `os`
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_istream<charT,traits>&
-    getline(basic_istream<charT,traits>& is,
-            basic_string<charT,traits,Allocator>& str,
-            charT delim);
-template<class charT, class traits, class Allocator>
-  basic_istream<charT,traits>&
-    getline(basic_istream<charT,traits>&& is,
-            basic_string<charT,traits,Allocator>& str,
-            charT delim);
-```
-*Effects:* Behaves as an unformatted input
-function ([[istream.unformatted]]), except that it does not affect the
-value returned by subsequent calls to `basic_istream<>::gcount()`. After
-constructing a `sentry` object, if the sentry converts to true, calls
-`str.erase()` and then extracts characters from `is` and appends them to
-`str` as if by calling `str.append(1, c)` until any of the following
-occurs:
-- end-of-file occurs on the input sequence (in which case, the `getline`
-  function calls `is.setstate(ios_base::eofbit)`).
-- `traits::eq(c, delim)` for the next available input character *c* (in
-  which case, *c* is extracted but not appended) ([[iostate.flags]])
-- `str.max_size()` characters are stored (in which case, the function
-  calls `is.setstate(ios_base::failbit))` ([[iostate.flags]])
-The conditions are tested in the order shown. In any case, after the
-last character is extracted, the `sentry` object `k` is destroyed.
-If the function extracts no characters, it calls
-`is.setstate(ios_base::failbit)` which may throw
-`ios_base::failure` ([[iostate.flags]]).
-*Returns:* `is`.
-``` cpp
-template<class charT, class traits, class Allocator>
-  basic_istream<charT,traits>&
-    getline(basic_istream<charT,traits>& is,
-            basic_string<charT,traits,Allocator>& str);
-template<class charT, class traits, class Allocator>
-  basic_istream<charT,traits>&
-    getline(basic_istream<charT,traits>&& is,
-            basic_string<charT,traits,Allocator>& str);
-```
-*Returns:* `getline(is,str,is.widen(’\n’))`

+### Class template `basic_string` <a id="basic.string">[[basic.string]]</a>
 The class template `basic_string` describes objects that can store a
 sequence consisting of a varying number of arbitrary char-like objects
 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
 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:
   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 pointer                = typename allocator_traits<Allocator>::pointer;
+    using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
+    using reference              = value_type&;
+    using const_reference        = const value_type&;
+ using iterator               = implementation-defined  // type of basic_string::iterator; // see [container.requirements]
+ using const_iterator         = implementation-defined  // type of basic_string::const_iterator; // see [container.requirements]
+ 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());
     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;
     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);
     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);
     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);
       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,
     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
 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]].
 | `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());
 ```
 | ------------ | ------------------------------------------------------------------------------------------------------ |
 | `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]].
 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]]).
 *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()`. |
 *Throws:* The second form throws nothing if
 `alloc == str.get_allocator()`.
+``` cpp
+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>;
+```
+*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);
 ```
 ``` 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 which is semantically equivalent to
 `reverse_iterator(begin())`.
+#### `basic_string` capacity <a id="string.capacity">[[string.capacity]]</a>
 ``` cpp
 size_type size() const noexcept;
 ```
 ``` 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:
 ``` cpp
 void resize(size_type n);
 ```
+*Effects:* As if by `resize(n, charT())`.
 ``` cpp
 size_type capacity() const noexcept;
 ```
 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;
 ```
 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.
 *Throws:* Nothing.
 *Complexity:* Constant time.
 ``` 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)`.
 *Effects:* Calls `append(il)`.
 *Returns:* `*this`.
+##### `basic_string::append` <a id="string.append">[[string.append]]</a>
 ``` cpp
 basic_string&
   append(const basic_string& str);
 ```
 ``` 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);
 ```
   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);
 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);
 ``` 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
 ``` 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);
 ```
 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.
 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`.
 *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`.
 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.
 *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
 ``` 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:* 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`), \[`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,
 *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;
 ```
 *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
 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))`.

Diff to HTML by rtfpessoa