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

Files changed (1) hide show

tmp/tmpbehb9c8q/{from.md → to.md} +1032 -1360

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

@@ -1,136 +1,101 @@
 ## String classes <a id="string.classes">[[string.classes]]</a>
 The header `<string>` defines the `basic_string` class template for
-manipulating varying-length sequences of char-like objects and four
-*typedef-name*s, `string`, `u16string`, `u32string`, and `wstring`, that
-name the specializations `basic_string<char>`, `basic_string<char16_t>`,
 `basic_string<char32_t>`, and `basic_string<{}wchar_t>`, respectively.
 ### Header `<string>` synopsis <a id="string.syn">[[string.syn]]</a>
 ``` cpp
-#include <initializer_list>
 namespace std {
   // [char.traits], character traits
   template<class charT> struct char_traits;
   template<> struct char_traits<char>;
   template<> struct char_traits<char16_t>;
   template<> struct char_traits<char32_t>;
   template<> struct char_traits<wchar_t>;
   // [basic.string], basic_string
-  template<class charT, class traits = char_traits<charT>,
-    class Allocator = allocator<charT>>
     class basic_string;
   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);
   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);
   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);
   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);
   template<class charT, class traits, class Allocator>
-    basic_string<charT, traits, Allocator>
       operator+(const charT* lhs,
                 const basic_string<charT, traits, Allocator>& rhs);
   template<class charT, class traits, class Allocator>
-    basic_string<charT, traits, Allocator>
       operator+(const charT* lhs,
                 basic_string<charT, traits, Allocator>&& rhs);
   template<class charT, class traits, class Allocator>
-    basic_string<charT, traits, Allocator>
-      operator+(charT lhs, const basic_string<charT, traits, Allocator>& rhs);
   template<class charT, class traits, class Allocator>
-    basic_string<charT, traits, Allocator>
-      operator+(charT lhs, basic_string<charT, traits, Allocator>&& rhs);
   template<class charT, class traits, class Allocator>
-    basic_string<charT, traits, Allocator>
       operator+(const basic_string<charT, traits, Allocator>& lhs,
                 const charT* rhs);
   template<class charT, class traits, class Allocator>
-    basic_string<charT, traits, Allocator>
       operator+(basic_string<charT, traits, Allocator>&& lhs,
                 const charT* rhs);
   template<class charT, class traits, class Allocator>
-    basic_string<charT, traits, Allocator>
-      operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);
   template<class charT, class traits, class Allocator>
-    basic_string<charT, traits, Allocator>
-      operator+(basic_string<charT, traits, Allocator>&& lhs, charT rhs);
   template<class charT, class traits, class Allocator>
- bool operator==(const basic_string<charT, traits, Allocator>& lhs,
- const basic_string<charT, traits, Allocator>& rhs) noexcept;
-  template<class charT, class traits, class Allocator>
-    bool operator==(const charT* lhs,
-                    const basic_string<charT, traits, Allocator>& rhs);
-  template<class charT, class traits, class Allocator>
-    bool operator==(const basic_string<charT, traits, Allocator>& lhs,
-                    const charT* rhs);
-  template<class charT, class traits, class Allocator>
-    bool operator!=(const basic_string<charT, traits, Allocator>& lhs,
                  const basic_string<charT, traits, Allocator>& rhs) noexcept;
   template<class charT, class traits, class Allocator>
-    bool operator!=(const charT* lhs,
-                    const basic_string<charT, traits, Allocator>& rhs);
-  template<class charT, class traits, class Allocator>
-    bool operator!=(const basic_string<charT, traits, Allocator>& lhs,
                               const charT* rhs);
   template<class charT, class traits, class Allocator>
- bool operator< (const basic_string<charT, traits, Allocator>& lhs,
- const basic_string<charT, traits, Allocator>& rhs) noexcept;
   template<class charT, class traits, class Allocator>
- bool operator< (const basic_string<charT, traits, Allocator>& lhs,
- const charT* rhs);
-  template<class charT, class traits, class Allocator>
-    bool operator< (const charT* lhs,
-                    const basic_string<charT, traits, Allocator>& rhs);
-  template<class charT, class traits, class Allocator>
-    bool operator> (const basic_string<charT, traits, Allocator>& lhs,
-                    const basic_string<charT, traits, Allocator>& rhs) noexcept;
-  template<class charT, class traits, class Allocator>
-    bool operator> (const basic_string<charT, traits, Allocator>& lhs,
-                    const charT* rhs);
-  template<class charT, class traits, class Allocator>
-    bool operator> (const charT* lhs,
-                    const basic_string<charT, traits, Allocator>& rhs);
-  template<class charT, class traits, class Allocator>
-    bool operator<=(const basic_string<charT, traits, Allocator>& lhs,
-                    const basic_string<charT, traits, Allocator>& rhs) noexcept;
-  template<class charT, class traits, class Allocator>
-    bool operator<=(const basic_string<charT, traits, Allocator>& lhs,
-                    const charT* rhs);
-  template<class charT, class traits, class Allocator>
-    bool operator<=(const charT* lhs,
-                    const basic_string<charT, traits, Allocator>& rhs);
-  template<class charT, class traits, class Allocator>
-    bool operator>=(const basic_string<charT, traits, Allocator>& lhs,
-                    const basic_string<charT, traits, Allocator>& rhs) noexcept;
-  template<class charT, class traits, class Allocator>
-    bool operator>=(const basic_string<charT, traits, Allocator>& lhs,
-                    const charT* rhs);
-  template<class charT, class traits, class Allocator>
-    bool operator>=(const charT* lhs,
-                    const basic_string<charT, traits, Allocator>& rhs);
   // [string.special], swap
   template<class charT, class traits, class Allocator>
- void swap(basic_string<charT, traits, Allocator>& lhs,
            basic_string<charT, traits, Allocator>& rhs)
         noexcept(noexcept(lhs.swap(rhs)));
   // [string.io], inserters and extractors
   template<class charT, class traits, class Allocator>
@@ -158,78 +123,94 @@ namespace std {
   template<class charT, class traits, class Allocator>
     basic_istream<charT, traits>&
       getline(basic_istream<charT, traits>&& is,
               basic_string<charT, traits, Allocator>& str);
   // basic_string typedef names
   using string    = basic_string<char>;
   using u16string = basic_string<char16_t>;
   using u32string = basic_string<char32_t>;
   using wstring   = basic_string<wchar_t>;
   // [string.conversions], numeric conversions
-  int stoi(const string& str, size_t* idx = 0, int base = 10);
-  long stol(const string& str, size_t* idx = 0, int base = 10);
-  unsigned long stoul(const string& str, size_t* idx = 0, int base = 10);
-  long long stoll(const string& str, size_t* idx = 0, int base = 10);
-  unsigned long long stoull(const string& str, size_t* idx = 0, int base = 10);
-  float stof(const string& str, size_t* idx = 0);
-  double stod(const string& str, size_t* idx = 0);
-  long double stold(const string& str, size_t* idx = 0);
   string to_string(int val);
   string to_string(unsigned val);
   string to_string(long val);
   string to_string(unsigned long val);
   string to_string(long long val);
   string to_string(unsigned long long val);
   string to_string(float val);
   string to_string(double val);
   string to_string(long double val);
-  int stoi(const wstring& str, size_t* idx = 0, int base = 10);
-  long stol(const wstring& str, size_t* idx = 0, int base = 10);
-  unsigned long stoul(const wstring& str, size_t* idx = 0, int base = 10);
-  long long stoll(const wstring& str, size_t* idx = 0, int base = 10);
-  unsigned long long stoull(const wstring& str, size_t* idx = 0, int base = 10);
-  float stof(const wstring& str, size_t* idx = 0);
-  double stod(const wstring& str, size_t* idx = 0);
-  long double stold(const wstring& str, size_t* idx = 0);
   wstring to_wstring(int val);
   wstring to_wstring(unsigned val);
   wstring to_wstring(long val);
   wstring to_wstring(unsigned long val);
   wstring to_wstring(long long val);
   wstring to_wstring(unsigned long long val);
   wstring to_wstring(float val);
   wstring to_wstring(double val);
   wstring to_wstring(long double val);
-  // [basic.string.hash], hash support
-  template<class T> struct hash;
-  template<> struct hash<string>;
-  template<> struct hash<u16string>;
-  template<> struct hash<u32string>;
-  template<> struct hash<wstring>;
   namespace pmr {
     template<class charT, class traits = char_traits<charT>>
-      using basic_string =
-        std::basic_string<charT, traits, polymorphic_allocator<charT>>;
     using string    = basic_string<char>;
     using u16string = basic_string<char16_t>;
     using u32string = basic_string<char32_t>;
     using wstring   = basic_string<wchar_t>;
   }
   inline namespace literals {
   inline namespace string_literals {
     // [basic.string.literals], suffix for basic_string literals
-    string    operator""s(const char* str, size_t len);
- u16string operator""s(const char16_t* str, size_t len);
- u32string operator""s(const char32_t* str, size_t len);
- wstring   operator""s(const wchar_t* str, size_t len);
   }
   }
 }
 ```
@@ -241,34 +222,24 @@ with the first element of the sequence at position zero. Such a sequence
 is also called a “string” if the type of the char-like objects that it
 holds is clear from context. In the rest of this Clause, the type of the
 char-like objects held in a `basic_string` object is designated by
 `charT`.
-The member functions of `basic_string` use an object of the `Allocator`
-class passed as a template parameter to allocate and free storage for
-the contained char-like objects.[^2]
-A `basic_string` is a contiguous container (
-[[container.requirements.general]]).
-In all cases, `size() <= capacity()`.
-The functions described in this Clause can report two kinds of errors,
-each associated with an exception type:
-- a *length* error is associated with exceptions of type
-  `length_error` ([[length.error]]);
-- an *out-of-range* error is associated with exceptions of type
-  `out_of_range` ([[out.of.range]]).
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
   class basic_string {
   public:
-    // types:
     using traits_type            = traits;
     using value_type             = charT;
     using allocator_type         = Allocator;
     using size_type              = typename allocator_traits<Allocator>::size_type;
     using difference_type        = typename allocator_traits<Allocator>::difference_type;
@@ -282,479 +253,434 @@ namespace std {
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     static const size_type npos  = -1;
     // [string.cons], construct/copy/destroy
-    basic_string() noexcept(noexcept(Allocator())) : basic_string(Allocator()) { }
-    explicit basic_string(const Allocator& a) noexcept;
-    basic_string(const basic_string& str);
-    basic_string(basic_string&& str) noexcept;
-    basic_string(const basic_string& str, size_type pos,
                            const Allocator& a = Allocator());
-    basic_string(const basic_string& str, size_type pos, size_type n,
                            const Allocator& a = Allocator());
     template<class T>
-      basic_string(const T& t, size_type pos, size_type n,
                              const Allocator& a = Allocator());
- explicit basic_string(basic_string_view<charT, traits> sv,
- const Allocator& a = Allocator());
-    basic_string(const charT* s,
-                 size_type n, const Allocator& a = Allocator());
-    basic_string(const charT* s, const Allocator& a = Allocator());
-    basic_string(size_type n, charT c, const Allocator& a = Allocator());
     template<class InputIterator>
-      basic_string(InputIterator begin, InputIterator end,
                              const Allocator& a = Allocator());
-    basic_string(initializer_list<charT>, const Allocator& = Allocator());
-    basic_string(const basic_string&, const Allocator&);
-    basic_string(basic_string&&, const Allocator&);
- ~basic_string();
-    basic_string& operator=(const basic_string& str);
-    basic_string& operator=(basic_string&& str)
       noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
                allocator_traits<Allocator>::is_always_equal::value);
- basic_string& operator=(basic_string_view<charT, traits> sv);
- basic_string& operator=(const charT* s);
-    basic_string& operator=(charT c);
-    basic_string& operator=(initializer_list<charT>);
     // [string.iterators], iterators
-    iterator       begin() noexcept;
-    const_iterator begin() const noexcept;
-    iterator       end() noexcept;
-    const_iterator end() const noexcept;
-    reverse_iterator       rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator       rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
-    const_iterator         cbegin() const noexcept;
-    const_iterator         cend() const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
     // [string.capacity], capacity
-    size_type size() const noexcept;
-    size_type length() const noexcept;
-    size_type max_size() const noexcept;
-    void resize(size_type n, charT c);
-    void resize(size_type n);
-    size_type capacity() const noexcept;
-    void reserve(size_type res_arg = 0);
-    void shrink_to_fit();
-    void clear() noexcept;
-    bool empty() const noexcept;
     // [string.access], element access
-    const_reference operator[](size_type pos) const;
-    reference       operator[](size_type pos);
-    const_reference at(size_type n) const;
-    reference       at(size_type n);
-    const charT& front() const;
-    charT&       front();
-    const charT& back() const;
-    charT&       back();
     // [string.modifiers], modifiers
-    basic_string& operator+=(const basic_string& str);
-    basic_string& operator+=(basic_string_view<charT, traits> sv);
-    basic_string& operator+=(const charT* s);
-    basic_string& operator+=(charT c);
-    basic_string& operator+=(initializer_list<charT>);
-    basic_string& append(const basic_string& str);
-    basic_string& append(const basic_string& str, size_type pos,
-                         size_type n = npos);
-    basic_string& append(basic_string_view<charT, traits> sv);
     template<class T>
-      basic_string& append(const T& t, size_type pos, size_type n = npos);
-    basic_string& append(const charT* s, size_type n);
-    basic_string& append(const charT* s);
-    basic_string& append(size_type n, charT c);
     template<class InputIterator>
-      basic_string& append(InputIterator first, InputIterator last);
-    basic_string& append(initializer_list<charT>);
-    void push_back(charT c);
- basic_string& assign(const basic_string& str);
-    basic_string& assign(basic_string&& str)
       noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
                allocator_traits<Allocator>::is_always_equal::value);
-    basic_string& assign(const basic_string& str, size_type pos,
-                         size_type n = npos);
-    basic_string& assign(basic_string_view<charT, traits> sv);
     template<class T>
-      basic_string& assign(const T& t, size_type pos, size_type n = npos);
- basic_string& assign(const charT* s, size_type n);
- basic_string& assign(const charT* s);
-    basic_string& assign(size_type n, charT c);
     template<class InputIterator>
-      basic_string& assign(InputIterator first, InputIterator last);
-    basic_string& assign(initializer_list<charT>);
-    basic_string& insert(size_type pos, const basic_string& str);
-    basic_string& insert(size_type pos1, const basic_string& str,
                                    size_type pos2, size_type n = npos);
-    basic_string& insert(size_type pos, basic_string_view<charT, traits> sv);
     template<class T>
-      basic_string& insert(size_type pos1, const T& t,
                                      size_type pos2, size_type n = npos);
-    basic_string& insert(size_type pos, const charT* s, size_type n);
-    basic_string& insert(size_type pos, const charT* s);
-    basic_string& insert(size_type pos, size_type n, charT c);
-    iterator insert(const_iterator p, charT c);
-    iterator insert(const_iterator p, size_type n, charT c);
     template<class InputIterator>
-      iterator insert(const_iterator p, InputIterator first, InputIterator last);
-    iterator insert(const_iterator p, initializer_list<charT>);
-    basic_string& erase(size_type pos = 0, size_type n = npos);
-    iterator erase(const_iterator p);
-    iterator erase(const_iterator first, const_iterator last);
-    void pop_back();
-    basic_string& replace(size_type pos1, size_type n1,
- const basic_string& str);
-    basic_string& replace(size_type pos1, size_type n1,
-                          const basic_string& str,
                                     size_type pos2, size_type n2 = npos);
-    basic_string& replace(size_type pos1, size_type n1,
-                          basic_string_view<charT, traits> sv);
     template<class T>
-      basic_string& replace(size_type pos1, size_type n1, const T& t,
                                       size_type pos2, size_type n2 = npos);
-    basic_string& replace(size_type pos, size_type n1, const charT* s,
- size_type n2);
-    basic_string& replace(size_type pos, size_type n1, const charT* s);
-    basic_string& replace(size_type pos, size_type n1, size_type n2,
-                          charT c);
-    basic_string& replace(const_iterator i1, const_iterator i2,
                                     const basic_string& str);
- basic_string& replace(const_iterator i1, const_iterator i2,
-                          basic_string_view<charT, traits> sv);
-    basic_string& replace(const_iterator i1, const_iterator i2, const charT* s,
                                     size_type n);
-    basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
-    basic_string& replace(const_iterator i1, const_iterator i2,
-                          size_type n, charT c);
     template<class InputIterator>
-      basic_string& replace(const_iterator i1, const_iterator i2,
                                       InputIterator j1, InputIterator j2);
-    basic_string& replace(const_iterator, const_iterator, initializer_list<charT>);
-    size_type copy(charT* s, size_type n, size_type pos = 0) const;
-    void swap(basic_string& str)
       noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
                allocator_traits<Allocator>::is_always_equal::value);
     // [string.ops], string operations
-    const charT* c_str() const noexcept;
-    const charT* data() const noexcept;
-    charT* data() noexcept;
-    operator basic_string_view<charT, traits>() const noexcept;
-    allocator_type get_allocator() const noexcept;
- size_type find (basic_string_view<charT, traits> sv,
- size_type pos = 0) const noexcept;
-    size_type find (const basic_string& str, size_type pos = 0) const noexcept;
-    size_type find (const charT* s, size_type pos, size_type n) const;
-    size_type find (const charT* s, size_type pos = 0) const;
-    size_type find (charT c, size_type pos = 0) const;
- size_type rfind(basic_string_view<charT, traits> sv,
- size_type pos = npos) const noexcept;
-    size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
-    size_type rfind(const charT* s, size_type pos, size_type n) const;
-    size_type rfind(const charT* s, size_type pos = npos) const;
-    size_type rfind(charT c, size_type pos = npos) const;
- size_type find_first_of(basic_string_view<charT, traits> sv,
- size_type pos = 0) const noexcept;
-    size_type find_first_of(const basic_string& str,
- size_type pos = 0) const noexcept;
-    size_type find_first_of(const charT* s,
- size_type pos, size_type n) const;
- size_type find_first_of(const charT* s, size_type pos = 0) const;
- size_type find_first_of(charT c, size_type pos = 0) const;
- size_type find_last_of (basic_string_view<charT, traits> sv,
- size_type pos = npos) const noexcept;
-    size_type find_last_of (const basic_string& str,
                                      size_type pos = npos) const noexcept;
-    size_type find_last_of (const charT* s,
- size_type pos, size_type n) const;
-    size_type find_last_of (const charT* s, size_type pos = npos) const;
-    size_type find_last_of (charT c, size_type pos = npos) const;
- size_type find_first_not_of(basic_string_view<charT, traits> sv,
- size_type pos = 0) const noexcept;
- size_type find_first_not_of(const basic_string& str,
                                           size_type pos = 0) const noexcept;
-    size_type find_first_not_of(const charT* s, size_type pos,
- size_type n) const;
-    size_type find_first_not_of(const charT* s, size_type pos = 0) const;
- size_type find_first_not_of(charT c, size_type pos = 0) const;
- size_type find_last_not_of (basic_string_view<charT, traits> sv,
- size_type pos = npos) const noexcept;
-    size_type find_last_not_of (const basic_string& str,
                                          size_type pos = npos) const noexcept;
-    size_type find_last_not_of (const charT* s, size_type pos,
- size_type n) const;
-    size_type find_last_not_of (const charT* s,
-                                size_type pos = npos) const;
-    size_type find_last_not_of (charT c, size_type pos = npos) const;
-    basic_string substr(size_type pos = 0, size_type n = npos) const;
-    int compare(basic_string_view<charT, traits> sv) const noexcept;
- int compare(size_type pos1, size_type n1,
-                basic_string_view<charT, traits> sv) const;
     template<class T>
-      int compare(size_type pos1, size_type n1, const T& t,
                             size_type pos2, size_type n2 = npos) const;
-    int compare(const basic_string& str) const noexcept;
-    int compare(size_type pos1, size_type n1,
- const basic_string& str) const;
-    int compare(size_type pos1, size_type n1,
-                const basic_string& str,
                           size_type pos2, size_type n2 = npos) const;
-    int compare(const charT* s) const;
-    int compare(size_type pos1, size_type n1,
- const charT* s) const;
-    int compare(size_type pos1, size_type n1,
-                const charT* s, size_type n2) const;
   };
   template<class InputIterator,
            class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
     basic_string(InputIterator, InputIterator, Allocator = Allocator())
       -> basic_string<typename iterator_traits<InputIterator>::value_type,
                       char_traits<typename iterator_traits<InputIterator>::value_type>,
                       Allocator>;
 }
 ```
-#### `basic_string` general requirements <a id="string.require">[[string.require]]</a>
 If any operation would cause `size()` to exceed `max_size()`, that
-operation shall throw an exception object of type `length_error`.
 If any member function or operator of `basic_string` throws an
-exception, that function or operator shall have no other effect.
 In every specialization `basic_string<charT, traits, Allocator>`, the
 type `allocator_traits<Allocator>::value_type` shall name the same type
 as `charT`. Every object of type
-`basic_string<charT, traits, Allocator>` shall use an object of type
 `Allocator` to allocate and free storage for the contained `charT`
-objects as needed. The `Allocator` object used shall be obtained as
-described in [[container.requirements.general]]. In every specialization
-`basic_string<charT, traits, Allocator>`, the type `traits` shall
-satisfy the character traits requirements ([[char.traits]]), and the
-type `traits::char_type` shall name the same type as `charT`.
 References, pointers, and iterators referring to the elements of a
 `basic_string` sequence may be invalidated by the following uses of that
 `basic_string` object:
-- as an argument to any standard library function taking a reference to
-  non-const `basic_string` as an argument.[^3]
 - Calling non-const member functions, except `operator[]`, `at`, `data`,
   `front`, `back`, `begin`, `rbegin`, `end`, and `rend`.
-#### `basic_string` constructors and assignment operators <a id="string.cons">[[string.cons]]</a>
 ``` cpp
-explicit basic_string(const Allocator& a) noexcept;
 ```
-*Effects:* Constructs an object of class `basic_string`. The
-postconditions of this function are indicated in
-Table  [[tab:strings.ctr.1]].
-**Table: `basic_string(const Allocator&)` effects** <a id="tab:strings.ctr.1">[tab:strings.ctr.1]</a>
-| Element      | Value                                                          |
-| ------------ | -------------------------------------------------------------- |
-| `data()`     | a non-null pointer that is copyable and can have 0 added to it |
-| `size()`     | 0                                                              |
-| `capacity()` | an unspecified value                                           |
 ``` cpp
-basic_string(const basic_string& str);
-basic_string(basic_string&& str) noexcept;
 ```
-*Effects:* Constructs an object of class `basic_string` as indicated in
-Table  [[tab:strings.ctr.cpy]]. In the second form, `str` is left in a
-valid state with an unspecified value.
-**Table: `basic_string(const basic_string&)` effects** <a id="tab:strings.ctr.cpy">[tab:strings.ctr.cpy]</a>
-| Element      | Value                                                                                                           |
-| ------------ | --------------------------------------------------------------------------------------------------------------- |
-| `data()`     | points at the first element of an allocated copy of the array whose first element is pointed at by `str.data()` |
-| `size()`     | `str.size()`                                                                                                    |
-| `capacity()` | a value at least as large as `size()`                                                                           |
 ``` cpp
-basic_string(const basic_string& str, size_type pos,
                        const Allocator& a = Allocator());
 ```
-*Throws:* `out_of_range` if `pos > str.size()`.
-*Effects:* Constructs an object of class `basic_string` and determines
-the effective length `rlen` of the initial string value as
-`str.size() - pos`, as indicated in Table  [[tab:strings.ctr.2]].
 ``` cpp
-basic_string(const basic_string& str, size_type pos, size_type n,
-             const Allocator& a = Allocator());
 ```
-*Throws:* `out_of_range` if `pos > str.size()`.
-*Effects:* Constructs an object of class `basic_string` and determines
-the effective length `rlen` of the initial string value as the smaller
-of `n` and `str.size() - pos`, as indicated in
-Table  [[tab:strings.ctr.2]].
-**Table: `basic_string(const basic_string&, size_type, const Allocator&)`\protect\mbox{ }and\protect
-`basic_string(const basic_string&, size_type, size_type, const Allocator&)` effects** <a id="tab:strings.ctr.2">[tab:strings.ctr.2]</a>
-| Element      | Value                                                                                                                                         |
-| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------- |
-| `data()`     | points at the first element of an allocated copy of `rlen` consecutive elements of the string controlled by `str` beginning at position `pos` |
-| `size()`     | `rlen`                                                                                                                                        |
-| `capacity()` | a value at least as large as `size()`                                                                                                         |
 ``` cpp
 template<class T>
-  basic_string(const T& t, size_type pos, size_type n,
-               const Allocator& a = Allocator());
 ```
 *Effects:* Creates a variable, `sv`, as if by
 `basic_string_view<charT, traits> sv = t;` and then behaves the same as:
 ``` cpp
 basic_string(sv.substr(pos, n), a);
 ```
-*Remarks:* This constructor shall not participate in overload resolution
-unless `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
-`true`.
 ``` cpp
-explicit basic_string(basic_string_view<charT, traits> sv,
- const Allocator& a = Allocator());
 ```
-*Effects:* Same as `basic_string(sv.data(), sv.size(), a)`.
 ``` cpp
-basic_string(const charT* s, size_type n,
-             const Allocator& a = Allocator());
 ```
-*Requires:* `s` points to an array of at least `n` elements of `charT`.
-*Effects:* Constructs an object of class `basic_string` and determines
-its initial string value from the array of `charT` of length `n` whose
-first element is designated by `s`, as indicated in
-Table  [[tab:strings.ctr.3]].
-**Table: `basic_string(const charT*, size_type, const Allocator&)` effects** <a id="tab:strings.ctr.3">[tab:strings.ctr.3]</a>
-| Element      | Value                                                                                                  |
-| ------------ | ------------------------------------------------------------------------------------------------------ |
-| `data()`     | points at the first element of an allocated copy of the array whose first element is pointed at by `s` |
-| `size()`     | `n`                                                                                                    |
-| `capacity()` | a value at least as large as `size()`                                                                  |
 ``` cpp
-basic_string(const charT* s, const Allocator& a = Allocator());
 ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Effects:* Constructs an object of class `basic_string` and determines
-its initial string value from the array of `charT` of length
-`traits::length(s)` whose first element is designated by `s`, as
-indicated in Table  [[tab:strings.ctr.4]].
-**Table: `basic_string(const charT*, const Allocator&)` effects** <a id="tab:strings.ctr.4">[tab:strings.ctr.4]</a>
-| Element      | Value                                                                                                  |
-| ------------ | ------------------------------------------------------------------------------------------------------ |
-| `data()`     | points at the first element of an allocated copy of the array whose first element is pointed at by `s` |
-| `size()`     | `traits::length(s)`                                                                                    |
-| `capacity()` | a value at least as large as `size()`                                                                  |
 ``` cpp
-basic_string(size_type n, charT c, const Allocator& a = Allocator());
 ```
-*Requires:* `n < npos`.
-*Effects:* Constructs an object of class `basic_string` and determines
-its initial string value by repeating the char-like object `c` for all
-`n` elements, as indicated in Table  [[tab:strings.ctr.5]].
-**Table: `basic_string(size_t, charT, const Allocator&)` effects** <a id="tab:strings.ctr.5">[tab:strings.ctr.5]</a>
-| Element      | Value                                                                                                 |
-| ------------ | ----------------------------------------------------------------------------------------------------- |
-| `data()`     | points at the first element of an allocated array of `n` elements, each storing the initial value `c` |
-| `size()`     | `n`                                                                                                   |
-| `capacity()` | a value at least as large as `size()`                                                                 |
 ``` cpp
 template<class InputIterator>
-  basic_string(InputIterator begin, InputIterator end,
-               const Allocator& a = Allocator());
 ```
-*Effects:* If `InputIterator` is an integral type, equivalent to:
-``` cpp
-basic_string(static_cast<size_type>(begin), static_cast<value_type>(end), a);
-```
-Otherwise constructs a string from the values in the range \[`begin`,
-`end`), as indicated in the Sequence Requirements table
-(see  [[sequence.reqmts]]).
 ``` cpp
-basic_string(initializer_list<charT> il, const Allocator& a = Allocator());
 ```
-*Effects:* Same as `basic_string(il.begin(), il.end(), a)`.
 ``` cpp
-basic_string(const basic_string& str, const Allocator& alloc);
-basic_string(basic_string&& str, const Allocator& alloc);
 ```
-*Effects:* Constructs an object of class `basic_string` as indicated in
-Table  [[tab:strings.ctr.6]]. The stored allocator is constructed from
-`alloc`. In the second form, `str` is left in a valid state with an
-unspecified value.
-**Table: `basic_string(const basic_string&, const Allocator&)`\protect and
-`basic_string(basic_string&&, const Allocator&)` effects** <a id="tab:strings.ctr.6">[tab:strings.ctr.6]</a>
-| Element           | Value                                                                                                                                  |
-| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
-| `data()`          | points at the first element of an allocated copy of the array whose first element is pointed at by the original value of `str.data()`. |
-| `size()`          | the original value of `str.size()`                                                                                                     |
-| `capacity()`      | a value at least as large as `size()`                                                                                                  |
-| `get_allocator()` | `alloc`                                                                                                                                |
 *Throws:* The second form throws nothing if
 `alloc == str.get_allocator()`.
 ``` cpp
@@ -764,226 +690,236 @@ template<class InputIterator,
     -> basic_string<typename iterator_traits<InputIterator>::value_type,
                     char_traits<typename iterator_traits<InputIterator>::value_type>,
                     Allocator>;
 ```
-*Remarks:* Shall not participate in overload resolution if
-`InputIterator` is a type that does not qualify as an input iterator, or
-if `Allocator` is a type that does not qualify as an
-allocator ([[container.requirements.general]]).
 ``` cpp
-basic_string& operator=(const basic_string& str);
 ```
-*Effects:* If `*this` and `str` are not the same object, modifies
-`*this` as shown in Table  [[tab:strings.op=]].
-If `*this` and `str` are the same object, the member has no effect.
 *Returns:* `*this`.
-**Table: `operator=(const basic_string&)` effects** <a id="tab:strings.op=">[tab:strings.op=]</a>
-| Element      | Value                                                                                                           |
-| ------------ | --------------------------------------------------------------------------------------------------------------- |
-| `data()`     | points at the first element of an allocated copy of the array whose first element is pointed at by `str.data()` |
-| `size()`     | `str.size()`                                                                                                    |
-| `capacity()` | a value at least as large as `size()`                                                                           |
 ``` cpp
-basic_string& operator=(basic_string&& str)
   noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
 *Effects:* Move assigns as a sequence
-container ([[container.requirements]]), except that iterators, pointers
 and references may be invalidated.
 *Returns:* `*this`.
 ``` cpp
-basic_string& operator=(basic_string_view<charT, traits> sv);
 ```
-*Effects:* Equivalent to: `return assign(sv);`
 ``` cpp
-basic_string& operator=(const charT* s);
 ```
-*Returns:* `*this = basic_string(s)`.
-*Remarks:* Uses `traits::length()`.
 ``` cpp
-basic_string& operator=(charT c);
 ```
-*Returns:* `*this = basic_string(1, c)`.
 ``` cpp
-basic_string& operator=(initializer_list<charT> il);
 ```
-*Effects:* As if by: `*this = basic_string(il);`
-*Returns:* `*this`.
-#### `basic_string` iterator support <a id="string.iterators">[[string.iterators]]</a>
 ``` cpp
-iterator       begin() noexcept;
-const_iterator begin() const noexcept;
-const_iterator cbegin() const noexcept;
 ```
 *Returns:* An iterator referring to the first character in the string.
 ``` cpp
-iterator       end() noexcept;
-const_iterator end() const noexcept;
-const_iterator cend() const noexcept;
 ```
 *Returns:* An iterator which is the past-the-end value.
 ``` cpp
-reverse_iterator       rbegin() noexcept;
-const_reverse_iterator rbegin() const noexcept;
-const_reverse_iterator crbegin() const noexcept;
 ```
 *Returns:* An iterator which is semantically equivalent to
 `reverse_iterator(end())`.
 ``` cpp
-reverse_iterator       rend() noexcept;
-const_reverse_iterator rend() const noexcept;
-const_reverse_iterator crend() const noexcept;
 ```
 *Returns:* An iterator which is semantically equivalent to
 `reverse_iterator(begin())`.
-#### `basic_string` capacity <a id="string.capacity">[[string.capacity]]</a>
 ``` cpp
-size_type size() const noexcept;
 ```
 *Returns:* A count of the number of char-like objects currently in the
 string.
 *Complexity:* Constant time.
 ``` cpp
-size_type length() const noexcept;
-```
-*Returns:* `size()`.
-``` cpp
-size_type max_size() const noexcept;
 ```
 *Returns:* The largest possible number of char-like objects that can be
 stored in a `basic_string`.
 *Complexity:* Constant time.
 ``` cpp
-void resize(size_type n, charT c);
 ```
-*Throws:* `length_error` if `n > max_size()`.
-*Effects:* Alters the length of the string designated by `*this` as
-follows:
-- If `n <= size()`, the function replaces the string designated by
-  `*this` with a string of length `n` whose elements are a copy of the
-  initial elements of the original string designated by `*this`.
-- If `n > size()`, the function replaces the string designated by
-  `*this` with a string of length `n` whose first `size()` elements are
-  a copy of the original string designated by `*this`, and whose
-  remaining elements are all initialized to `c`.
 ``` cpp
-void resize(size_type n);
 ```
-*Effects:* As if by `resize(n, charT())`.
 ``` cpp
-size_type capacity() const noexcept;
 ```
 *Returns:* The size of the allocated storage in the string.
 ``` cpp
-void reserve(size_type res_arg=0);
 ```
-The member function `reserve()` is a directive that informs a
-`basic_string` object of a planned change in size, so that it can manage
-the storage allocation accordingly.
-*Effects:* After `reserve()`, `capacity()` is greater or equal to the
-argument of `reserve`.
-[*Note 1*: Calling `reserve()` with a `res_arg` argument less than
-`capacity()` is in effect a non-binding shrink request. A call with
-`res_arg <= size()` is in effect a non-binding shrink-to-fit
-request. — *end note*]
-*Throws:* `length_error` if `res_arg > max_size()`.[^4]
 ``` cpp
-void shrink_to_fit();
 ```
 *Effects:* `shrink_to_fit` is a non-binding request to reduce
 `capacity()` to `size()`.
-[*Note 2*: The request is non-binding to allow latitude for
 implementation-specific optimizations. — *end note*]
 It does not increase `capacity()`, but may reduce `capacity()` by
 causing reallocation.
-*Complexity:* Linear in the size of the sequence.
 *Remarks:* Reallocation invalidates all the references, pointers, and
-iterators referring to the elements in the sequence as well as the
-past-the-end iterator. If no reallocation happens, they remain valid.
-``` cpp
-void clear() noexcept;
-```
-*Effects:* Behaves as if the function calls:
 ``` cpp
-erase(begin(), end());
 ```
 ``` cpp
-bool empty() const noexcept;
 ```
-*Returns:* `size() == 0`.
-#### `basic_string` element access <a id="string.access">[[string.access]]</a>
 ``` cpp
-const_reference operator[](size_type pos) const;
-reference       operator[](size_type pos);
 ```
-*Requires:* `pos <= size()`.
 *Returns:* `*(begin() + pos)` if `pos < size()`. Otherwise, returns a
 reference to an object of type `charT` with value `charT()`, where
 modifying the object to any value other than `charT()` leads to
 undefined behavior.
@@ -991,1026 +927,800 @@ undefined behavior.
 *Throws:* Nothing.
 *Complexity:* Constant time.
 ``` cpp
-const_reference at(size_type pos) const;
-reference       at(size_type pos);
 ```
 *Throws:* `out_of_range` if `pos >= size()`.
 *Returns:* `operator[](pos)`.
 ``` cpp
-const charT& front() const;
-charT& front();
 ```
-*Requires:* `!empty()`.
 *Effects:* Equivalent to: `return operator[](0);`
 ``` cpp
-const charT& back() const;
-charT& back();
 ```
-*Requires:* `!empty()`.
 *Effects:* Equivalent to: `return operator[](size() - 1);`
-#### `basic_string` modifiers <a id="string.modifiers">[[string.modifiers]]</a>
-##### `basic_string::operator+=` <a id="string.op+=">[[string.op+=]]</a>
 ``` cpp
-basic_string&
-  operator+=(const basic_string& str);
 ```
-*Effects:* Calls `append(str)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& operator+=(basic_string_view<charT, traits> sv);
 ```
-*Effects:* Calls `append(sv)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& operator+=(const charT* s);
 ```
-*Effects:* Calls `append(s)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& operator+=(charT c);
 ```
-*Effects:* Calls `push_back(c)`;
-*Returns:* `*this`.
 ``` cpp
-basic_string& operator+=(initializer_list<charT> il);
 ```
-*Effects:* Calls `append(il)`.
-*Returns:* `*this`.
 ##### `basic_string::append` <a id="string.append">[[string.append]]</a>
 ``` cpp
-basic_string&
-  append(const basic_string& str);
 ```
-*Effects:* Calls `append(str.data(), str.size())`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  append(const basic_string& str, size_type pos, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos > str.size()`.
-*Effects:* Determines the effective length `rlen` of the string to
-append as the smaller of `n` and `str``.size() - ``pos` and calls
-`append(str.data() + pos, rlen)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& append(basic_string_view<charT, traits> sv);
 ```
-*Effects:* Equivalent to: `return append(sv.data(), sv.size());`
 ``` cpp
 template<class T>
-  basic_string& append(const T& t, size_type pos, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos > sv.size()`.
-*Effects:* Creates a variable, `sv`, as if by
-`basic_string_view<charT, traits> sv = t`. Determines the effective
-length `rlen` of the string to append as the smaller of `n` and
-`sv.size() - pos` and calls `append(sv.data() + pos, rlen)`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
-`true` and `is_convertible_v<const T&, const charT*>` is `false`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  append(const charT* s, size_type n);
 ```
-*Requires:* `s` points to an array of at least `n` elements of `charT`.
-*Throws:* `length_error` if `size() + n > max_size()`.
-*Effects:* The function replaces the string controlled by `*this` with a
-string of length `size() + n` whose first `size()` elements are a copy
-of the original string controlled by `*this` and whose remaining
-elements are a copy of the initial `n` elements of `s`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& append(const charT* s);
 ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Effects:* Calls `append(s, traits::length(s))`.
 *Returns:* `*this`.
 ``` cpp
-basic_string& append(size_type n, charT c);
 ```
-*Effects:* Equivalent to `append(basic_string(n, c))`.
 *Returns:* `*this`.
 ``` cpp
 template<class InputIterator>
-  basic_string& append(InputIterator first, InputIterator last);
 ```
-*Requires:* \[`first`, `last`) is a valid range.
-*Effects:* Equivalent to
-`append(basic_string(first, last, get_allocator()))`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& append(initializer_list<charT> il);
 ```
-*Effects:* Calls `append(il.begin(), il.size())`.
-*Returns:* `*this`.
 ``` cpp
-void push_back(charT c);
 ```
-*Effects:* Equivalent to `append(static_cast<size_type>(1), c)`.
 ##### `basic_string::assign` <a id="string.assign">[[string.assign]]</a>
 ``` cpp
-basic_string& assign(const basic_string& str);
 ```
-*Effects:* Equivalent to `*this = str`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& assign(basic_string&& str)
   noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
-*Effects:* Equivalent to `*this = std::move(str)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  assign(const basic_string& str, size_type pos,
-         size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos > str.size()`.
-*Effects:* Determines the effective length `rlen` of the string to
-assign as the smaller of `n` and `str``.size() - ``pos` and calls
-`assign(str.data() + pos, rlen)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& assign(basic_string_view<charT, traits> sv);
 ```
-*Effects:* Equivalent to: `return assign(sv.data(), sv.size());`
 ``` cpp
 template<class T>
-  basic_string& assign(const T& t, size_type pos, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos > sv.size()`.
-*Effects:* Creates a variable, `sv`, as if by
-`basic_string_view<charT, traits> sv = t`. Determines the effective
-length `rlen` of the string to assign as the smaller of `n` and
-`sv.size() - pos` and calls `assign(sv.data() + pos, rlen)`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
-`true` and `is_convertible_v<const T&, const charT*>` is `false`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& assign(const charT* s, size_type n);
 ```
-*Requires:* `s` points to an array of at least `n` elements of `charT`.
-*Throws:* `length_error` if `n > max_size()`.
-*Effects:* Replaces the string controlled by `*this` with a string of
-length `n` whose elements are a copy of those pointed to by `s`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& assign(const charT* s);
 ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Effects:* Calls `assign(s, traits::length(s))`.
 *Returns:* `*this`.
 ``` cpp
-basic_string& assign(initializer_list<charT> il);
 ```
-*Effects:* Calls `assign(il.begin(), il.size())`.
-`*this`.
 ``` cpp
-basic_string& assign(size_type n, charT c);
 ```
-*Effects:* Equivalent to `assign(basic_string(n, c))`.
-*Returns:* `*this`.
 ``` cpp
 template<class InputIterator>
-  basic_string& assign(InputIterator first, InputIterator last);
 ```
-*Effects:* Equivalent to
-`assign(basic_string(first, last, get_allocator()))`.
-*Returns:* `*this`.
 ##### `basic_string::insert` <a id="string.insert">[[string.insert]]</a>
 ``` cpp
-basic_string&
-  insert(size_type pos,
-         const basic_string& str);
 ```
 *Effects:* Equivalent to: `return insert(pos, str.data(), str.size());`
 ``` cpp
-basic_string&
-  insert(size_type pos1,
-         const basic_string& str,
                                size_type pos2, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos1 > size()` or `pos2 > str.size()`.
-*Effects:* Determines the effective length `rlen` of the string to
-insert as the smaller of `n` and `str.size() - pos2` and calls
-`insert(pos1, str.data() + pos2, rlen)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& insert(size_type pos, basic_string_view<charT, traits> sv);
 ```
-*Effects:* Equivalent to: `return insert(pos, sv.data(), sv.size());`
 ``` cpp
 template<class T>
-  basic_string& insert(size_type pos1, const T& t,
                                  size_type pos2, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos1 > size()` or `pos2 > sv.size()`.
-*Effects:* Creates a variable, `sv`, as if by
-`basic_string_view<charT, traits> sv = t`. Determines the effective
-length `rlen` of the string to assign as the smaller of `n` and
-`sv.size() - pos2` and calls `insert(pos1, sv.data() + pos2, rlen)`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
-`true` and `is_convertible_v<const T&, const charT*>` is `false`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  insert(size_type pos, const charT* s, size_type n);
 ```
-*Requires:* `s` points to an array of at least `n` elements of `charT`.
-*Throws:* `out_of_range` if `pos > size()` or `length_error` if
-`size() + n > max_size()`.
-*Effects:* Replaces the string controlled by `*this` with a string of
-length `size() + n` whose first `pos` elements are a copy of the initial
-elements of the original string controlled by `*this` and whose next `n`
-elements are a copy of the elements in `s` and whose remaining elements
-are a copy of the remaining elements of the original string controlled
-by `*this`.
 *Returns:* `*this`.
 ``` cpp
-basic_string&
-  insert(size_type pos, const charT* s);
 ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
 *Effects:* Equivalent to: `return insert(pos, s, traits::length(s));`
 ``` cpp
-basic_string&
-  insert(size_type pos, size_type n, charT c);
 ```
-*Effects:* Equivalent to `insert(pos, basic_string(n, c))`.
-*Returns:* `*this`.
 ``` cpp
-iterator insert(const_iterator p, charT c);
 ```
-*Requires:* `p` is a valid iterator on `*this`.
-*Effects:* Inserts a copy of `c` before the character referred to by
-`p`.
-*Returns:* An iterator which refers to the copy of the inserted
-character.
 ``` cpp
-iterator insert(const_iterator p, size_type n, charT c);
 ```
-*Requires:* `p` is a valid iterator on `*this`.
-*Effects:* Inserts `n` copies of `c` before the character referred to by
-`p`.
-*Returns:* An iterator which refers to the copy of the first inserted
-character, or `p` if `n == 0`.
 ``` cpp
 template<class InputIterator>
-  iterator insert(const_iterator p, InputIterator first, InputIterator last);
 ```
-*Requires:* `p` is a valid iterator on `*this`. `[first, last)` is a
-valid range.
 *Effects:* Equivalent to
 `insert(p - begin(), basic_string(first, last, get_allocator()))`.
-*Returns:* An iterator which refers to the copy of the first inserted
-character, or `p` if `first == last`.
 ``` cpp
-iterator insert(const_iterator p, initializer_list<charT> il);
 ```
-*Effects:* As if by `insert(p, il.begin(), il.end())`.
-*Returns:* An iterator which refers to the copy of the first inserted
-character, or `p` if `i1` is empty.
 ##### `basic_string::erase` <a id="string.erase">[[string.erase]]</a>
 ``` cpp
-basic_string& erase(size_type pos = 0, size_type n = npos);
 ```
 *Throws:* `out_of_range` if `pos` `> size()`.
 *Effects:* Determines the effective length `xlen` of the string to be
-removed as the smaller of `n` and `size() - pos`.
-The function then replaces the string controlled by `*this` with a
-string of length `size() - xlen` whose first `pos` elements are a copy
-of the initial elements of the original string controlled by `*this`,
-and whose remaining elements are a copy of the elements of the original
-string controlled by `*this` beginning at position `pos + xlen`.
 *Returns:* `*this`.
 ``` cpp
-iterator erase(const_iterator p);
 ```
 *Throws:* Nothing.
 *Effects:* Removes the character referred to by `p`.
 *Returns:* An iterator which points to the element immediately following
 `p` prior to the element being erased. If no such element exists,
 `end()` is returned.
 ``` cpp
-iterator erase(const_iterator first, const_iterator last);
 ```
-*Requires:* `first` and `last` are valid iterators on `*this`, defining
-a range `[first, last)`.
 *Throws:* Nothing.
 *Effects:* Removes the characters in the range `[first, last)`.
 *Returns:* An iterator which points to the element pointed to by `last`
 prior to the other elements being erased. If no such element exists,
 `end()` is returned.
 ``` cpp
-void pop_back();
 ```
-*Requires:* `!empty()`.
 *Throws:* Nothing.
-*Effects:* Equivalent to `erase(size() - 1, 1)`.
 ##### `basic_string::replace` <a id="string.replace">[[string.replace]]</a>
 ``` cpp
-basic_string&
-  replace(size_type pos1, size_type n1,
-          const basic_string& str);
 ```
 *Effects:* Equivalent to:
 `return replace(pos1, n1, str.data(), str.size());`
 ``` cpp
-basic_string&
-  replace(size_type pos1, size_type n1,
-          const basic_string& str,
                                 size_type pos2, size_type n2 = npos);
 ```
-*Throws:* `out_of_range` if `pos1 > size()` or `pos2 > str.size()`.
-*Effects:* Determines the effective length `rlen` of the string to be
-inserted as the smaller of `n2` and `str.size() - pos2` and calls
-`replace(pos1, n1, str.data() + pos2, rlen)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(size_type pos1, size_type n1,
-                      basic_string_view<charT, traits> sv);
 ```
 *Effects:* Equivalent to:
-`return replace(pos1, n1, sv.data(), sv.size());`
 ``` cpp
 template<class T>
-  basic_string& replace(size_type pos1, size_type n1, const T& t,
                                   size_type pos2, size_type n2 = npos);
 ```
-*Throws:* `out_of_range` if `pos1 > size()` or `pos2 > sv.size()`.
-*Effects:* Creates a variable, `sv`, as if by
-`basic_string_view<charT, traits> sv = t`. Determines the effective
-length `rlen` of the string to be inserted as the smaller of `n2` and
-`sv.size() - pos2` and calls
-`replace(pos1, n1, sv.data() + pos2, rlen)`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
-`true` and `is_convertible_v<const T&, const charT*>` is `false`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  replace(size_type pos1, size_type n1, const charT* s, size_type n2);
 ```
-*Requires:* `s` points to an array of at least `n2` elements of `charT`.
-*Throws:* `out_of_range` if `pos1 > size()` or `length_error` if the
-length of the resulting string would exceed `max_size()` (see below).
 *Effects:* Determines the effective length `xlen` of the string to be
 removed as the smaller of `n1` and `size() - pos1`. If
 `size() - xlen >= max_size() - n2` throws `length_error`. Otherwise, the
-function replaces the string controlled by \*`this` with a string of
-length `size() - xlen + n2` whose first `pos1` elements are a copy of
-the initial elements of the original string controlled by `*this`, whose
-next `n2` elements are a copy of the initial `n2` elements of `s`, and
-whose remaining elements are a copy of the elements of the original
-string controlled by `*this` beginning at position `pos + xlen`.
 *Returns:* `*this`.
 ``` cpp
-basic_string&
-  replace(size_type pos, size_type n, const charT* s);
 ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
 *Effects:* Equivalent to:
 `return replace(pos, n, s, traits::length(s));`
 ``` cpp
-basic_string&
-  replace(size_type pos1, size_type n1,
-          size_type n2, charT c);
 ```
-*Effects:* Equivalent to `replace(pos1, n1, basic_string(n2, c))`.
 *Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, str)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2,
-                      basic_string_view<charT, traits> sv);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, sv)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
- replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges and
-`s` points to an array of at least `n` elements of `charT`.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, s, n)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges and
-`s` points to an array of at least `traits::length(s) + 1` elements of
-`charT`.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, s, traits::length(s))`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2, size_type n,
-                      charT c);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, basic_string(n, c))`.
-*Returns:* `*this`.
 ``` cpp
 template<class InputIterator>
-  basic_string& replace(const_iterator i1, const_iterator i2,
                                   InputIterator j1, InputIterator j2);
 ```
-*Requires:* \[`begin()`, `i1`), \[`i1`, `i2`) and \[`j1`, `j2`) are
-valid ranges.
-*Effects:* Calls
-`replace(i1 - begin(), i2 - i1, basic_string(j1, j2, get_allocator()))`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2,
-                      initializer_list<charT> il);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
-*Effects:* Calls
-`replace(i1 - begin(), i2 - i1, il.begin(), il.size())`.
-*Returns:* `*this`.
 ##### `basic_string::copy` <a id="string.copy">[[string.copy]]</a>
 ``` cpp
-size_type copy(charT* s, size_type n, size_type pos = 0) const;
 ```
-Let `rlen` be the smaller of `n` and `size() - pos`.
-*Throws:* `out_of_range` if `pos > size()`.
-*Requires:* \[`s`, `s + rlen`) is a valid range.
-*Effects:* Equivalent to: `traits::copy(s, data() + pos, rlen)`.
 [*Note 1*: This does not terminate `s` with a null
 object. — *end note*]
-*Returns:* `rlen`.
 ##### `basic_string::swap` <a id="string.swap">[[string.swap]]</a>
 ``` cpp
-void swap(basic_string& s)
   noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
-*Postconditions:* `*this` contains the same sequence of characters that
-was in `s`, `s` contains the same sequence of characters that was in
-`*this`.
 *Throws:* Nothing.
 *Complexity:* Constant time.
-#### `basic_string` string operations <a id="string.ops">[[string.ops]]</a>
-##### `basic_string` accessors <a id="string.accessors">[[string.accessors]]</a>
 ``` cpp
-const charT* c_str() const noexcept;
-const charT* data() const noexcept;
 ```
-*Returns:* A pointer `p` such that `p + i == &operator[](i)` for each
-`i` in \[`0`, `size()`\].
 *Complexity:* Constant time.
-*Requires:* The program shall not alter any of the values stored in the
-character array.
 ``` cpp
-charT* data() noexcept;
 ```
-*Returns:* A pointer `p` such that `p + i == &operator[](i)` for each
-`i` in \[`0`, `size()`\].
 *Complexity:* Constant time.
-*Requires:* The program shall not alter the value stored at
-`p + size()`.
 ``` cpp
-operator basic_string_view<charT, traits>() const noexcept;
 ```
 *Effects:* Equivalent to:
 `return basic_string_view<charT, traits>(data(), size());`
 ``` cpp
-allocator_type get_allocator() const noexcept;
 ```
 *Returns:* A copy of the `Allocator` object used to construct the string
 or, if that allocator has been replaced, a copy of the most recent
 replacement.
-##### `basic_string::find` <a id="string.find">[[string.find]]</a>
-``` cpp
-size_type find(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
-```
-*Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions hold:
-- `pos <= xpos` and `xpos + sv.size() <= size()`;
-- `traits::eq(at(xpos + I), sv.at(I))` for all elements `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
-``` cpp
-size_type find(const basic_string& str, size_type pos = 0) const noexcept;
-```
-*Effects:* Equivalent to:
-`return find(basic_string_view<charT, traits>(str), pos);`
-``` cpp
-size_type find(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:* `find(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find(const charT* s, size_type pos = 0) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `find(basic_string_view<charT, traits>(s), pos)`.
-``` cpp
-size_type find(charT c, size_type pos = 0) const;
-```
-*Returns:* `find(basic_string(1, c), pos)`.
-##### `basic_string::rfind` <a id="string.rfind">[[string.rfind]]</a>
-``` cpp
-size_type rfind(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
-```
-*Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions hold:
-- `xpos <= pos` and `xpos + sv.size() <= size()`;
-- `traits::eq(at(xpos + I), sv.at(I))` for all elements `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
-``` cpp
-size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
-```
-*Effects:* Equivalent to:
-`return rfind(basic_string_view<charT, traits>(str), pos);`
-``` cpp
-size_type rfind(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:* `rfind(basic_string_view<charT, traits>(s, n), pos)`.
   ``` cpp
-size_type rfind(const charT* s, size_type pos = npos) const;
   ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `rfind(basic_string_view<charT, traits>(s), pos)`.
   ``` cpp
-size_type rfind(charT c, size_type pos = npos) const;
   ```
-*Returns:* `rfind(basic_string(1, c), pos)`.
-##### `basic_string::find_first_of` <a id="string.find.first.of">[[string.find.first.of]]</a>
   ``` cpp
-size_type find_first_of(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
   ```
-*Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions hold:
-- `pos <= xpos` and `xpos < size()`;
-- `traits::eq(at(xpos), sv.at(I))` for some element `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
   ``` cpp
-size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
   ```
-*Effects:* Equivalent to:
-`return find_first_of(basic_string_view<charT, traits>(str), pos);`
   ``` cpp
-size_type find_first_of(const charT* s, size_type pos, size_type n) const;
   ```
-*Returns:* `find_first_of(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find_first_of(const charT* s, size_type pos = 0) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `find_first_of(basic_string_view<charT, traits>(s), pos)`.
-``` cpp
-size_type find_first_of(charT c, size_type pos = 0) const;
-```
-*Returns:* `find_first_of(basic_string(1, c), pos)`.
-##### `basic_string::find_last_of` <a id="string.find.last.of">[[string.find.last.of]]</a>
-``` cpp
-size_type find_last_of(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
-```
-*Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions hold:
-- `xpos <= pos` and `xpos < size()`;
-- `traits::eq(at(xpos), sv.at(I))` for some element `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
 ``` cpp
-size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept;
 ```
-*Effects:* Equivalent to:
-`return find_last_of(basic_string_view<charT, traits>(str), pos);`
-``` cpp
-size_type find_last_of(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:* `find_last_of(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find_last_of(const charT* s, size_type pos = npos) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `find_last_of(basic_string_view<charT, traits>(s), pos)`.
-``` cpp
-size_type find_last_of(charT c, size_type pos = npos) const;
-```
-*Returns:* `find_last_of(basic_string(1, c), pos)`.
-##### `basic_string::find_first_not_of` <a id="string.find.first.not.of">[[string.find.first.not.of]]</a>
-``` cpp
-size_type find_first_not_of(basic_string_view<charT, traits> sv,
-                            size_type pos = 0) const noexcept;
-```
-*Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions hold:
-- `pos <= xpos` and `xpos < size()`;
-- `traits::eq(at(xpos), sv.at(I))` for no element `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
-``` cpp
-size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept;
-```
-*Effects:* Equivalent to:
-``` cpp
-return find_first_not_of(basic_string_view<charT, traits>(str), pos);
-```
-``` cpp
-size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:*
-`find_first_not_of(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find_first_not_of(const charT* s, size_type pos = 0) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:*
-`find_first_not_of(basic_string_view<charT, traits>(s), pos)`.
-``` cpp
-size_type find_first_not_of(charT c, size_type pos = 0) const;
-```
-*Returns:* `find_first_not_of(basic_string(1, c), pos)`.
-##### `basic_string::find_last_not_of` <a id="string.find.last.not.of">[[string.find.last.not.of]]</a>
-``` cpp
-size_type find_last_not_of(basic_string_view<charT, traits> sv,
-                           size_type pos = npos) const noexcept;
-```
-*Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions hold:
-- `xpos <= pos` and `xpos < size()`;
-- `traits::eq(at(xpos), sv.at(I))` for no element `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
-``` cpp
-size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept;
-```
-*Effects:* Equivalent to:
-``` cpp
-return find_last_not_of(basic_string_view<charT, traits>(str), pos);
-```
-``` cpp
-size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:*
-`find_last_not_of(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find_last_not_of(const charT* s, size_type pos = npos) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `find_last_not_of(basic_string_view<charT, traits>(s), pos)`.
 ``` cpp
-size_type find_last_not_of(charT c, size_type pos = npos) const;
 ```
-*Returns:* `find_last_not_of(basic_string(1, c), pos)`.
 ##### `basic_string::substr` <a id="string.substr">[[string.substr]]</a>
 ``` cpp
-basic_string substr(size_type pos = 0, size_type n = npos) const;
 ```
 *Throws:* `out_of_range` if `pos > size()`.
 *Effects:* Determines the effective length `rlen` of the string to copy
@@ -2019,409 +1729,327 @@ 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))`.
-### `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))`.
-[*Note 1*: Or equivalently,
-`std::move(rhs.insert(0, lhs))`. — *end note*]
 ``` 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)
       noexcept(noexcept(lhs.swap(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
@@ -2434,12 +2062,12 @@ following occurs:
 After the last character (if any) is extracted, `is.width(0)` is called
 and the `sentry` object 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>
@@ -2463,30 +2091,30 @@ template<class charT, class traits, class Allocator>
             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 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>
@@ -2499,21 +2127,53 @@ template<class charT, class traits, class Allocator>
             basic_string<charT, traits, Allocator>& str);
 ```
 *Returns:* `getline(is, str, is.widen(’\n’))`.
 ### Numeric conversions <a id="string.conversions">[[string.conversions]]</a>
 ``` cpp
-int stoi(const string& str, size_t* idx = 0, int base = 10);
-long stol(const string& str, size_t* idx = 0, int base = 10);
-unsigned long stoul(const string& str, size_t* idx = 0, int base = 10);
-long long stoll(const string& str, size_t* idx = 0, int base = 10);
-unsigned long long stoull(const string& str, size_t* idx = 0, int base = 10);
 ```
-*Effects:* the first two functions call
 `strtol(str.c_str(), ptr, base)`, and the last three functions call
 `strtoul(str.c_str(), ptr, base)`, `strtoll(str.c_str(), ptr, base)`,
 and `strtoull(str.c_str(), ptr, base)`, respectively. Each function
 returns the converted result, if any. The argument `ptr` designates a
 pointer to an object internal to the function that is used to determine
@@ -2528,13 +2188,13 @@ unconverted element of `str`.
 `out_of_range` if `strtol`, `strtoul`, `strtoll` or `strtoull` sets
 `errno` to `ERANGE`, or if the converted value is outside the range of
 representable values for the return type.
 ``` cpp
-float stof(const string& str, size_t* idx = 0);
-double stod(const string& str, size_t* idx = 0);
-long double stold(const string& str, size_t* idx = 0);
 ```
 *Effects:* These functions call `strtof(str.c_str(), ptr)`,
 `strtod(str.c_str(), ptr)`, and `strtold(str.c_str(), ptr)`,
 respectively. Each function returns the converted result, if any. The
@@ -2569,18 +2229,18 @@ calling `sprintf(buf, fmt, val)` with a format specifier of `"%d"`,
 `"%u"`, `"%ld"`, `"%lu"`, `"%lld"`, `"%llu"`, `"%f"`, `"%f"`, or
 `"%Lf"`, respectively, where `buf` designates an internal character
 buffer of sufficient size.
 ``` cpp
-int stoi(const wstring& str, size_t* idx = 0, int base = 10);
-long stol(const wstring& str, size_t* idx = 0, int base = 10);
-unsigned long stoul(const wstring& str, size_t* idx = 0, int base = 10);
-long long stoll(const wstring& str, size_t* idx = 0, int base = 10);
-unsigned long long stoull(const wstring& str, size_t* idx = 0, int base = 10);
 ```
-*Effects:* the first two functions call
 `wcstol(str.c_str(), ptr, base)`, and the last three functions call
 `wcstoul(str.c_str(), ptr, base)`, `wcstoll(str.c_str(), ptr, base)`,
 and `wcstoull(str.c_str(), ptr, base)`, respectively. Each function
 returns the converted result, if any. The argument `ptr` designates a
 pointer to an object internal to the function that is used to determine
@@ -2594,13 +2254,13 @@ unconverted element of `str`.
 `wcstoull` reports that no conversion could be performed. Throws
 `out_of_range` if the converted value is outside the range of
 representable values for the return type.
 ``` cpp
-float stof(const wstring& str, size_t* idx = 0);
-double stod(const wstring& str, size_t* idx = 0);
-long double stold(const wstring& str, size_t* idx = 0);
 ```
 *Effects:* These functions call `wcstof(str.c_str(), ptr)`,
 `wcstod(str.c_str(), ptr)`, and `wcstold(str.c_str(), ptr)`,
 respectively. Each function returns the converted result, if any. The
@@ -2636,41 +2296,53 @@ internal character buffer of sufficient size `buffsz`.
 ### Hash support <a id="basic.string.hash">[[basic.string.hash]]</a>
 ``` cpp
 template<> struct hash<string>;
 template<> struct hash<u16string>;
 template<> struct hash<u32string>;
 template<> struct hash<wstring>;
 ```
 If `S` is one of these string types, `SV` is the corresponding string
 view type, and `s` is an object of type `S`, then
 `hash<S>()(s) == hash<SV>()(SV(s))`.
 ### Suffix for `basic_string` literals <a id="basic.string.literals">[[basic.string.literals]]</a>
 ``` cpp
-string operator""s(const char* str, size_t len);
 ```
 *Returns:* `string{str, len}`.
 ``` cpp
-u16string operator""s(const char16_t* str, size_t len);
 ```
 *Returns:* `u16string{str, len}`.
 ``` cpp
-u32string operator""s(const char32_t* str, size_t len);
 ```
 *Returns:* `u32string{str, len}`.
 ``` cpp
-wstring operator""s(const wchar_t* str, size_t len);
 ```
 *Returns:* `wstring{str, len}`.
 [*Note 1*: The same suffix `s` is used for `chrono::duration` literals

 ## String classes <a id="string.classes">[[string.classes]]</a>
 The header `<string>` defines the `basic_string` class template for
+manipulating varying-length sequences of char-like objects and five
+*typedef-name*s, `string`, `u8string`, `u16string`, `u32string`, and
+`wstring`, that name the specializations `basic_string<char>`,
+`basic_string<char8_t>`, `basic_string<char16_t>`,
 `basic_string<char32_t>`, and `basic_string<{}wchar_t>`, respectively.
 ### Header `<string>` synopsis <a id="string.syn">[[string.syn]]</a>
 ``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   // [char.traits], character traits
   template<class charT> struct char_traits;
   template<> struct char_traits<char>;
+  template<> struct char_traits<char8_t>;
   template<> struct char_traits<char16_t>;
   template<> struct char_traits<char32_t>;
   template<> struct char_traits<wchar_t>;
   // [basic.string], basic_string
+  template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_string;
   template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
       operator+(const basic_string<charT, traits, Allocator>& lhs,
                 const basic_string<charT, traits, Allocator>& rhs);
   template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
       operator+(basic_string<charT, traits, Allocator>&& lhs,
                 const basic_string<charT, traits, Allocator>& rhs);
   template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
       operator+(const basic_string<charT, traits, Allocator>& lhs,
                 basic_string<charT, traits, Allocator>&& rhs);
   template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
       operator+(basic_string<charT, traits, Allocator>&& lhs,
                 basic_string<charT, traits, Allocator>&& rhs);
   template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
       operator+(const charT* lhs,
                 const basic_string<charT, traits, Allocator>& rhs);
   template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
       operator+(const charT* lhs,
                 basic_string<charT, traits, Allocator>&& rhs);
   template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
+      operator+(charT lhs,
+                const basic_string<charT, traits, Allocator>& rhs);
   template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
+      operator+(charT lhs,
+                basic_string<charT, traits, Allocator>&& rhs);
   template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
       operator+(const basic_string<charT, traits, Allocator>& lhs,
                 const charT* rhs);
   template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
       operator+(basic_string<charT, traits, Allocator>&& lhs,
                 const charT* rhs);
   template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
+      operator+(const basic_string<charT, traits, Allocator>& lhs,
+                charT rhs);
   template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
+      operator+(basic_string<charT, traits, Allocator>&& lhs,
+                charT rhs);
   template<class charT, class traits, class Allocator>
+ constexpr bool
+      operator==(const basic_string<charT, traits, Allocator>& lhs,
                  const basic_string<charT, traits, Allocator>& rhs) noexcept;
   template<class charT, class traits, class Allocator>
+ constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
                               const charT* rhs);
   template<class charT, class traits, class Allocator>
+ constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
+              \itcorr                      const basic_string<charT, traits, Allocator>& rhs) noexcept;
   template<class charT, class traits, class Allocator>
+ constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
+              \itcorr                      const charT* rhs);
   // [string.special], swap
   template<class charT, class traits, class Allocator>
+ constexpr void
+      swap(basic_string<charT, traits, Allocator>& lhs,
            basic_string<charT, traits, Allocator>& rhs)
         noexcept(noexcept(lhs.swap(rhs)));
   // [string.io], inserters and extractors
   template<class charT, class traits, class Allocator>
   template<class charT, class traits, class Allocator>
     basic_istream<charT, traits>&
       getline(basic_istream<charT, traits>&& is,
               basic_string<charT, traits, Allocator>& str);
+  // [string.erasure], erasure
+  template<class charT, class traits, class Allocator, class U>
+    constexpr typename basic_string<charT, traits, Allocator>::size_type
+      erase(basic_string<charT, traits, Allocator>& c, const U& value);
+  template<class charT, class traits, class Allocator, class Predicate>
+    constexpr typename basic_string<charT, traits, Allocator>::size_type
+      erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred);
   // basic_string typedef names
   using string    = basic_string<char>;
+  using u8string  = basic_string<char8_t>;
   using u16string = basic_string<char16_t>;
   using u32string = basic_string<char32_t>;
   using wstring   = basic_string<wchar_t>;
   // [string.conversions], numeric conversions
+  int stoi(const string& str, size_t* idx = nullptr, int base = 10);
+  long stol(const string& str, size_t* idx = nullptr, int base = 10);
+  unsigned long stoul(const string& str, size_t* idx = nullptr, int base = 10);
+  long long stoll(const string& str, size_t* idx = nullptr, int base = 10);
+  unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);
+  float stof(const string& str, size_t* idx = nullptr);
+  double stod(const string& str, size_t* idx = nullptr);
+  long double stold(const string& str, size_t* idx = nullptr);
   string to_string(int val);
   string to_string(unsigned val);
   string to_string(long val);
   string to_string(unsigned long val);
   string to_string(long long val);
   string to_string(unsigned long long val);
   string to_string(float val);
   string to_string(double val);
   string to_string(long double val);
+  int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);
+  long stol(const wstring& str, size_t* idx = nullptr, int base = 10);
+  unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);
+  long long stoll(const wstring& str, size_t* idx = nullptr, int base = 10);
+  unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);
+  float stof(const wstring& str, size_t* idx = nullptr);
+  double stod(const wstring& str, size_t* idx = nullptr);
+  long double stold(const wstring& str, size_t* idx = nullptr);
   wstring to_wstring(int val);
   wstring to_wstring(unsigned val);
   wstring to_wstring(long val);
   wstring to_wstring(unsigned long val);
   wstring to_wstring(long long val);
   wstring to_wstring(unsigned long long val);
   wstring to_wstring(float val);
   wstring to_wstring(double val);
   wstring to_wstring(long double val);
   namespace pmr {
     template<class charT, class traits = char_traits<charT>>
+      using basic_string = std::basic_string<charT, traits, polymorphic_allocator<charT>>;
     using string    = basic_string<char>;
+    using u8string  = basic_string<char8_t>;
     using u16string = basic_string<char16_t>;
     using u32string = basic_string<char32_t>;
     using wstring   = basic_string<wchar_t>;
   }
+  // [basic.string.hash], hash support
+  template<class T> struct hash;
+  template<> struct hash<string>;
+  template<> struct hash<u8string>;
+  template<> struct hash<u16string>;
+  template<> struct hash<u32string>;
+  template<> struct hash<wstring>;
+  template<> struct hash<pmr::string>;
+  template<> struct hash<pmr::u8string>;
+  template<> struct hash<pmr::u16string>;
+  template<> struct hash<pmr::u32string>;
+  template<> struct hash<pmr::wstring>;
   inline namespace literals {
   inline namespace string_literals {
     // [basic.string.literals], suffix for basic_string literals
+ constexpr string    operator""s(const char* str, size_t len);
+ constexpr u8string  operator""s(const char8_t* str, size_t len);
+ constexpr u16string operator""s(const char16_t* str, size_t len);
+ constexpr u32string operator""s(const char32_t* str, size_t len);
+    constexpr wstring   operator""s(const wchar_t* str, size_t len);
   }
   }
 }
 ```
 is also called a “string” if the type of the char-like objects that it
 holds is clear from context. In the rest of this Clause, the type of the
 char-like objects held in a `basic_string` object is designated by
 `charT`.
+A specialization of `basic_string` is a contiguous container
+[[container.requirements.general]].
+In all cases, \[`data()`, `data() + size()`\] is a valid range,
+`data() + size()` points at an object with value `charT()` (a “null
+terminator”), and `size() <= capacity()` is `true`.
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
   class basic_string {
   public:
+    // types
     using traits_type            = traits;
     using value_type             = charT;
     using allocator_type         = Allocator;
     using size_type              = typename allocator_traits<Allocator>::size_type;
     using difference_type        = typename allocator_traits<Allocator>::difference_type;
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     static const size_type npos  = -1;
     // [string.cons], construct/copy/destroy
+ constexpr basic_string() noexcept(noexcept(Allocator())) : basic_string(Allocator()) { }
+ constexpr explicit basic_string(const Allocator& a) noexcept;
+ constexpr basic_string(const basic_string& str);
+ constexpr basic_string(basic_string&& str) noexcept;
+ constexpr basic_string(const basic_string& str, size_type pos,
                            const Allocator& a = Allocator());
+ constexpr basic_string(const basic_string& str, size_type pos, size_type n,
                            const Allocator& a = Allocator());
     template<class T>
+ constexpr basic_string(const T& t, size_type pos, size_type n,
                              const Allocator& a = Allocator());
+ template<class T>
+      constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
+ constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
+    constexpr basic_string(const charT* s, const Allocator& a = Allocator());
+ constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
     template<class InputIterator>
+ constexpr basic_string(InputIterator begin, InputIterator end,
                              const Allocator& a = Allocator());
+ constexpr basic_string(initializer_list<charT>, const Allocator& = Allocator());
+ constexpr basic_string(const basic_string&, const Allocator&);
+ constexpr basic_string(basic_string&&, const Allocator&);
+    constexpr ~basic_string();
+ constexpr basic_string& operator=(const basic_string& str);
+ constexpr basic_string& operator=(basic_string&& str)
       noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
                allocator_traits<Allocator>::is_always_equal::value);
+ template<class T>
+      constexpr basic_string& operator=(const T& t);
+ constexpr basic_string& operator=(const charT* s);
+ constexpr basic_string& operator=(charT c);
+    constexpr basic_string& operator=(initializer_list<charT>);
     // [string.iterators], iterators
+ constexpr iterator       begin() noexcept;
+ constexpr const_iterator begin() const noexcept;
+ constexpr iterator       end() noexcept;
+ constexpr const_iterator end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // [string.capacity], capacity
+ constexpr size_type size() const noexcept;
+ constexpr size_type length() const noexcept;
+ constexpr size_type max_size() const noexcept;
+ constexpr void resize(size_type n, charT c);
+ constexpr void resize(size_type n);
+ constexpr size_type capacity() const noexcept;
+ constexpr void reserve(size_type res_arg);
+ constexpr void shrink_to_fit();
+ constexpr void clear() noexcept;
+ [[nodiscard]] constexpr bool empty() const noexcept;
     // [string.access], element access
+ constexpr const_reference operator[](size_type pos) const;
+ constexpr reference       operator[](size_type pos);
+ constexpr const_reference at(size_type n) const;
+ constexpr reference       at(size_type n);
+ constexpr const charT& front() const;
+ constexpr charT&       front();
+ constexpr const charT& back() const;
+ constexpr charT&       back();
     // [string.modifiers], modifiers
+ constexpr basic_string& operator+=(const basic_string& str);
     template<class T>
+ constexpr basic_string& operator+=(const T& t);
+ constexpr basic_string& operator+=(const charT* s);
+ constexpr basic_string& operator+=(charT c);
+ constexpr basic_string& operator+=(initializer_list<charT>);
+    constexpr basic_string& append(const basic_string& str);
+    constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);
+    template<class T>
+      constexpr basic_string& append(const T& t);
+    template<class T>
+      constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);
+    constexpr basic_string& append(const charT* s, size_type n);
+    constexpr basic_string& append(const charT* s);
+    constexpr basic_string& append(size_type n, charT c);
     template<class InputIterator>
+ constexpr basic_string& append(InputIterator first, InputIterator last);
+ constexpr basic_string& append(initializer_list<charT>);
+ constexpr void push_back(charT c);
+    constexpr basic_string& assign(const basic_string& str);
+    constexpr basic_string& assign(basic_string&& str)
       noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
                allocator_traits<Allocator>::is_always_equal::value);
+ constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);
     template<class T>
+ constexpr basic_string& assign(const T& t);
+ template<class T>
+      constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);
+ constexpr basic_string& assign(const charT* s, size_type n);
+    constexpr basic_string& assign(const charT* s);
+    constexpr basic_string& assign(size_type n, charT c);
     template<class InputIterator>
+ constexpr basic_string& assign(InputIterator first, InputIterator last);
+ constexpr basic_string& assign(initializer_list<charT>);
+ constexpr basic_string& insert(size_type pos, const basic_string& str);
+ constexpr basic_string& insert(size_type pos1, const basic_string& str,
                                    size_type pos2, size_type n = npos);
     template<class T>
+ constexpr basic_string& insert(size_type pos, const T& t);
+    template<class T>
+      constexpr basic_string& insert(size_type pos1, const T& t,
                                      size_type pos2, size_type n = npos);
+ constexpr basic_string& insert(size_type pos, const charT* s, size_type n);
+ constexpr basic_string& insert(size_type pos, const charT* s);
+ constexpr basic_string& insert(size_type pos, size_type n, charT c);
+ constexpr iterator insert(const_iterator p, charT c);
+ constexpr iterator insert(const_iterator p, size_type n, charT c);
     template<class InputIterator>
+ constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
+ constexpr iterator insert(const_iterator p, initializer_list<charT>);
+ constexpr basic_string& erase(size_type pos = 0, size_type n = npos);
+ constexpr iterator erase(const_iterator p);
+ constexpr iterator erase(const_iterator first, const_iterator last);
+ constexpr void pop_back();
+ constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
+    constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
                                     size_type pos2, size_type n2 = npos);
     template<class T>
+ constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);
+    template<class T>
+      constexpr basic_string& replace(size_type pos1, size_type n1, const T& t,
                                       size_type pos2, size_type n2 = npos);
+ constexpr basic_string& replace(size_type pos, size_type n1, const charT* s, size_type n2);
+    constexpr basic_string& replace(size_type pos, size_type n1, const charT* s);
+ constexpr basic_string& replace(size_type pos, size_type n1, size_type n2, charT c);
+ constexpr basic_string& replace(const_iterator i1, const_iterator i2,
                                     const basic_string& str);
+ template<class T>
+      constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
+ constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s,
                                     size_type n);
+ constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
+ constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);
     template<class InputIterator>
+ constexpr basic_string& replace(const_iterator i1, const_iterator i2,
                                       InputIterator j1, InputIterator j2);
+ constexpr basic_string& replace(const_iterator, const_iterator, initializer_list<charT>);
+ constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
+    constexpr void swap(basic_string& str)
       noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
                allocator_traits<Allocator>::is_always_equal::value);
     // [string.ops], string operations
+ constexpr const charT* c_str() const noexcept;
+ constexpr const charT* data() const noexcept;
+ constexpr charT* data() noexcept;
+ constexpr operator basic_string_view<charT, traits>() const noexcept;
+ constexpr allocator_type get_allocator() const noexcept;
+ template<class T>
+      constexpr size_type find(const T& t, size_type pos = 0) const noexcept(see below);
+ constexpr size_type find(const basic_string& str, size_type pos = 0) const noexcept;
+ constexpr size_type find(const charT* s, size_type pos, size_type n) const;
+ constexpr size_type find(const charT* s, size_type pos = 0) const;
+ constexpr size_type find(charT c, size_type pos = 0) const noexcept;
+ template<class T>
+      constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(see below);
+ constexpr size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
+ constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
+ constexpr size_type rfind(const charT* s, size_type pos = npos) const;
+ constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
+ template<class T>
+      constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(see below);
+ constexpr size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
+    constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
+ constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
+    constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
+ template<class T>
+      constexpr size_type find_last_of(const T& t,
+ size_type pos = npos) const noexcept(see below);
+    constexpr size_type find_last_of(const basic_string& str,
                                      size_type pos = npos) const noexcept;
+ constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
+    constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
+ constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
+ template<class T>
+      constexpr size_type find_first_not_of(const T& t,
+ size_type pos = 0) const noexcept(see below);
+    constexpr size_type find_first_not_of(const basic_string& str,
                                           size_type pos = 0) const noexcept;
+ constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
+    constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
+ constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
+ template<class T>
+      constexpr size_type find_last_not_of(const T& t,
+ size_type pos = npos) const noexcept(see below);
+ constexpr size_type find_last_not_of(const basic_string& str,
                                          size_type pos = npos) const noexcept;
+ constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
+    constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
+ constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
+ constexpr basic_string substr(size_type pos = 0, size_type n = npos) const;
+ template<class T>
+      constexpr int compare(const T& t) const noexcept(see below);
     template<class T>
+ constexpr int compare(size_type pos1, size_type n1, const T& t) const;
+    template<class T>
+      constexpr int compare(size_type pos1, size_type n1, const T& t,
                             size_type pos2, size_type n2 = npos) const;
+ constexpr int compare(const basic_string& str) const noexcept;
+ constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
+    constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
                           size_type pos2, size_type n2 = npos) const;
+ constexpr int compare(const charT* s) const;
+ constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
+    constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
+    constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
+    constexpr bool starts_with(charT x) const noexcept;
+    constexpr bool starts_with(const charT* x) const;
+    constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
+    constexpr bool ends_with(charT x) const noexcept;
+    constexpr bool ends_with(const charT* x) const;
   };
   template<class InputIterator,
            class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
     basic_string(InputIterator, InputIterator, Allocator = Allocator())
       -> basic_string<typename iterator_traits<InputIterator>::value_type,
                       char_traits<typename iterator_traits<InputIterator>::value_type>,
                       Allocator>;
+  template<class charT,
+           class traits,
+           class Allocator = allocator<charT>>
+    explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
+      -> basic_string<charT, traits, Allocator>;
+  template<class charT,
+           class traits,
+           class Allocator = allocator<charT>>
+    basic_string(basic_string_view<charT, traits>,
+                 typename see below::size_type, typename see below::size_type,
+                 const Allocator& = Allocator())
+      -> basic_string<charT, traits, Allocator>;
 }
 ```
+A `size_type` parameter type in a `basic_string` deduction guide refers
+to the `size_type` member type of the type deduced by the deduction
+guide.
+#### General requirements <a id="string.require">[[string.require]]</a>
 If any operation would cause `size()` to exceed `max_size()`, that
+operation throws an exception object of type `length_error`.
 If any member function or operator of `basic_string` throws an
+exception, that function or operator has no other effect on the
+`basic_string` object.
 In every specialization `basic_string<charT, traits, Allocator>`, the
 type `allocator_traits<Allocator>::value_type` shall name the same type
 as `charT`. Every object of type
+`basic_string<charT, traits, Allocator>` uses an object of type
 `Allocator` to allocate and free storage for the contained `charT`
+objects as needed. The `Allocator` object used is obtained as described
+in [[container.requirements.general]]. In every specialization
+`basic_string<charT, traits, Allocator>`, the type `traits` shall meet
+the character traits requirements [[char.traits]].
+[*Note 1*: The program is ill-formed if `traits::char_type` is not the
+same type as `charT`. — *end note*]
 References, pointers, and iterators referring to the elements of a
 `basic_string` sequence may be invalidated by the following uses of that
 `basic_string` object:
+- Passing as an argument to any standard library function taking a
+ reference to non-const `basic_string` as an argument.[^2]
 - Calling non-const member functions, except `operator[]`, `at`, `data`,
   `front`, `back`, `begin`, `rbegin`, `end`, and `rend`.
+#### Constructors and assignment operators <a id="string.cons">[[string.cons]]</a>
 ``` cpp
+constexpr explicit basic_string(const Allocator& a) noexcept;
 ```
+*Ensures:* `size()` is equal to `0`.
 ``` cpp
+constexpr basic_string(const basic_string& str);
+constexpr basic_string(basic_string&& str) noexcept;
 ```
+*Effects:* Constructs an object whose value is that of `str` prior to
+this call.
+*Remarks:* In the second form, `str` is left in a valid but unspecified
+state.
 ``` cpp
+constexpr basic_string(const basic_string& str, size_type pos,
+                       const Allocator& a = Allocator());
+constexpr basic_string(const basic_string& str, size_type pos, size_type n,
                        const Allocator& a = Allocator());
 ```
+*Effects:* Let `n` be `npos` for the first overload. Equivalent to:
 ``` cpp
+basic_string(basic_string_view<charT, traits>(str).substr(pos, n), a)
 ```
 ``` cpp
 template<class T>
+ constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
 ```
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
 *Effects:* Creates a variable, `sv`, as if by
 `basic_string_view<charT, traits> sv = t;` and then behaves the same as:
 ``` cpp
 basic_string(sv.substr(pos, n), a);
 ```
 ``` cpp
+template<class T>
+  constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Creates a variable, `sv`, as if by
+`basic_string_view<charT, traits> sv = t;` and then behaves the same as
+`basic_string(sv.data(), sv.size(), a)`.
 ``` cpp
+constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
 ```
+*Preconditions:* \[`s`, `s + n`) is a valid range.
+*Effects:* Constructs an object whose initial value is the range \[`s`,
+`s + n`).
+*Ensures:* `size()` is equal to `n`, and `traits::compare(data(), s, n)`
+is equal to `0`.
 ``` cpp
+constexpr basic_string(const charT* s, const Allocator& a = Allocator());
 ```
+*Constraints:* `Allocator` is a type that qualifies as an
+allocator [[container.requirements.general]].
+[*Note 1*: This affects class template argument
+deduction. — *end note*]
+*Effects:* Equivalent to: `basic_string(s, traits::length(s), a)`.
 ``` cpp
+constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
 ```
+*Constraints:* `Allocator` is a type that qualifies as an
+allocator [[container.requirements.general]].
+[*Note 2*: This affects class template argument
+deduction. — *end note*]
+*Effects:* Constructs an object whose value consists of `n` copies of
+`c`.
 ``` cpp
 template<class InputIterator>
+ constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
 ```
+*Constraints:* `InputIterator` is a type that qualifies as an input
+iterator [[container.requirements.general]].
+*Effects:* Constructs a string from the values in the range \[`begin`,
+`end`), as indicated in [[container.seq.req]].
 ``` cpp
+constexpr basic_string(initializer_list<charT> il, const Allocator& a = Allocator());
 ```
+*Effects:* Equivalent to `basic_string(il.begin(), il.end(), a)`.
 ``` cpp
+constexpr basic_string(const basic_string& str, const Allocator& alloc);
+constexpr basic_string(basic_string&& str, const Allocator& alloc);
 ```
+*Effects:* Constructs an object whose value is that of `str` prior to
+this call. The stored allocator is constructed from `alloc`. In the
+second form, `str` is left in a valid but unspecified state.
 *Throws:* The second form throws nothing if
 `alloc == str.get_allocator()`.
 ``` cpp
     -> basic_string<typename iterator_traits<InputIterator>::value_type,
                     char_traits<typename iterator_traits<InputIterator>::value_type>,
                     Allocator>;
 ```
+*Constraints:* `InputIterator` is a type that qualifies as an input
+iterator, and `Allocator` is a type that qualifies as an
+allocator [[container.requirements.general]].
 ``` cpp
+template<class charT,
+         class traits,
+         class Allocator = allocator<charT>>
+  explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
+    -> basic_string<charT, traits, Allocator>;
+template<class charT,
+         class traits,
+         class Allocator = allocator<charT>>
+  basic_string(basic_string_view<charT, traits>,
+               typename see below::size_type, typename see below::size_type,
+               const Allocator& = Allocator())
+    -> basic_string<charT, traits, Allocator>;
 ```
+*Constraints:* `Allocator` is a type that qualifies as an
+allocator [[container.requirements.general]].
+``` cpp
+constexpr basic_string& operator=(const basic_string& str);
+```
+*Effects:* If `*this` and `str` are the same object, has no effect.
+Otherwise, replaces the value of `*this` with a copy of `str`.
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& operator=(basic_string&& str)
   noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
 *Effects:* Move assigns as a sequence
+container [[container.requirements]], except that iterators, pointers
 and references may be invalidated.
 *Returns:* `*this`.
 ``` cpp
+template<class T>
+  constexpr basic_string& operator=(const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
 ``` cpp
+basic_string_view<charT, traits> sv = t;
+return assign(sv);
 ```
+``` cpp
+constexpr basic_string& operator=(const charT* s);
+```
+*Effects:* Equivalent to:
+`return *this = basic_string_view<charT, traits>(s);`
 ``` cpp
+constexpr basic_string& operator=(charT c);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+return *this = basic_string_view<charT, traits>(addressof(c), 1);
 ```
+``` cpp
+constexpr basic_string& operator=(initializer_list<charT> il);
+```
+*Effects:* Equivalent to:
+``` cpp
+return *this = basic_string_view<charT, traits>(il.begin(), il.size());
+```
+#### Iterator support <a id="string.iterators">[[string.iterators]]</a>
 ``` cpp
+constexpr iterator       begin() noexcept;
+constexpr const_iterator begin() const noexcept;
+constexpr const_iterator cbegin() const noexcept;
 ```
 *Returns:* An iterator referring to the first character in the string.
 ``` cpp
+constexpr iterator       end() noexcept;
+constexpr const_iterator end() const noexcept;
+constexpr const_iterator cend() const noexcept;
 ```
 *Returns:* An iterator which is the past-the-end value.
 ``` cpp
+constexpr reverse_iterator       rbegin() noexcept;
+constexpr const_reverse_iterator rbegin() const noexcept;
+constexpr const_reverse_iterator crbegin() const noexcept;
 ```
 *Returns:* An iterator which is semantically equivalent to
 `reverse_iterator(end())`.
 ``` cpp
+constexpr reverse_iterator       rend() noexcept;
+constexpr const_reverse_iterator rend() const noexcept;
+constexpr const_reverse_iterator crend() const noexcept;
 ```
 *Returns:* An iterator which is semantically equivalent to
 `reverse_iterator(begin())`.
+#### Capacity <a id="string.capacity">[[string.capacity]]</a>
 ``` cpp
+constexpr size_type size() const noexcept;
+constexpr size_type length() const noexcept;
 ```
 *Returns:* A count of the number of char-like objects currently in the
 string.
 *Complexity:* Constant time.
 ``` cpp
+constexpr size_type max_size() const noexcept;
 ```
 *Returns:* The largest possible number of char-like objects that can be
 stored in a `basic_string`.
 *Complexity:* Constant time.
 ``` cpp
+constexpr void resize(size_type n, charT c);
 ```
+*Effects:* Alters the value of `*this` as follows:
+- If `n <= size()`, erases the last `size() - n` elements.
+- If `n > size()`, appends `n - size()` copies of `c`.
 ``` cpp
+constexpr void resize(size_type n);
 ```
+*Effects:* Equivalent to `resize(n, charT())`.
 ``` cpp
+constexpr size_type capacity() const noexcept;
 ```
 *Returns:* The size of the allocated storage in the string.
+*Complexity:* Constant time.
 ``` cpp
+constexpr void reserve(size_type res_arg);
 ```
+*Effects:* A directive that informs a `basic_string` of a planned change
+in size, so that the storage allocation can be managed accordingly.
+After `reserve()`, `capacity()` is greater or equal to the argument of
+`reserve` if reallocation happens; and equal to the previous value of
+`capacity()` otherwise. Reallocation happens at this point if and only
+if the current capacity is less than the argument of `reserve()`.
+*Throws:* `length_error` if `res_arg > max_size()` or any exceptions
+thrown by `allocator_traits` `<Allocator>::allocate`.
 ``` cpp
+constexpr void shrink_to_fit();
 ```
 *Effects:* `shrink_to_fit` is a non-binding request to reduce
 `capacity()` to `size()`.
+[*Note 1*: The request is non-binding to allow latitude for
 implementation-specific optimizations. — *end note*]
 It does not increase `capacity()`, but may reduce `capacity()` by
 causing reallocation.
+*Complexity:* If the size is not equal to the old capacity, linear in
+the size of the sequence; otherwise constant.
 *Remarks:* Reallocation invalidates all the references, pointers, and
+iterators referring to the elements in the sequence, as well as the
+past-the-end iterator.
+[*Note 2*: If no reallocation happens, they remain
+valid. — *end note*]
 ``` cpp
+constexpr void clear() noexcept;
 ```
+*Effects:* Equivalent to: `erase(begin(), end());`
 ``` cpp
+[[nodiscard]] constexpr bool empty() const noexcept;
 ```
+*Effects:* Equivalent to: `return size() == 0;`
+#### Element access <a id="string.access">[[string.access]]</a>
 ``` cpp
+constexpr const_reference operator[](size_type pos) const;
+constexpr reference       operator[](size_type pos);
 ```
+*Preconditions:* `pos <= size()`.
 *Returns:* `*(begin() + pos)` if `pos < size()`. Otherwise, returns a
 reference to an object of type `charT` with value `charT()`, where
 modifying the object to any value other than `charT()` leads to
 undefined behavior.
 *Throws:* Nothing.
 *Complexity:* Constant time.
 ``` cpp
+constexpr const_reference at(size_type pos) const;
+constexpr reference       at(size_type pos);
 ```
 *Throws:* `out_of_range` if `pos >= size()`.
 *Returns:* `operator[](pos)`.
 ``` cpp
+constexpr const charT& front() const;
+constexpr charT& front();
 ```
+*Preconditions:* `!empty()`.
 *Effects:* Equivalent to: `return operator[](0);`
 ``` cpp
+constexpr const charT& back() const;
+constexpr charT& back();
 ```
+*Preconditions:* `!empty()`.
 *Effects:* Equivalent to: `return operator[](size() - 1);`
+#### Modifiers <a id="string.modifiers">[[string.modifiers]]</a>
+##### `basic_string::operator+=` <a id="string.op.append">[[string.op.append]]</a>
 ``` cpp
+constexpr basic_string& operator+=(const basic_string& str);
 ```
+*Effects:* Equivalent to: `return append(str);`
 ``` cpp
+template<class T>
+  constexpr basic_string& operator+=(const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
 ``` cpp
+basic_string_view<charT, traits> sv = t;
+return append(sv);
 ```
+``` cpp
+constexpr basic_string& operator+=(const charT* s);
+```
+*Effects:* Equivalent to: `return append(s);`
 ``` cpp
+constexpr basic_string& operator+=(charT c);
 ```
+*Effects:* Equivalent to: `return append(size_type{1}, c);`
 ``` cpp
+constexpr basic_string& operator+=(initializer_list<charT> il);
 ```
+*Effects:* Equivalent to: `return append(il);`
 ##### `basic_string::append` <a id="string.append">[[string.append]]</a>
 ``` cpp
+constexpr basic_string& append(const basic_string& str);
 ```
+*Effects:* Equivalent to: `return append(str.data(), str.size());`
 ``` cpp
+constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+return append(basic_string_view<charT, traits>(str).substr(pos, n));
 ```
 ``` cpp
 template<class T>
+ constexpr basic_string& append(const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+ `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return append(sv.data(), sv.size());
+```
 ``` cpp
+template<class T>
+ constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return append(sv.substr(pos, n));
+```
 ``` cpp
+constexpr basic_string& append(const charT* s, size_type n);
 ```
+*Preconditions:* \[`s`, `s + n`) is a valid range.
+*Effects:* Appends a copy of the range \[`s`, `s + n`) to the string.
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& append(const charT* s);
+```
+*Effects:* Equivalent to: `return append(s, traits::length(s));`
+``` cpp
+constexpr basic_string& append(size_type n, charT c);
 ```
+*Effects:* Appends `n` copies of `c` to the string.
 *Returns:* `*this`.
 ``` cpp
 template<class InputIterator>
+ constexpr basic_string& append(InputIterator first, InputIterator last);
 ```
+*Constraints:* `InputIterator` is a type that qualifies as an input
+iterator [[container.requirements.general]].
+*Effects:* Equivalent to:
+`return append(basic_string(first, last, get_allocator()));`
 ``` cpp
+constexpr basic_string& append(initializer_list<charT> il);
 ```
+*Effects:* Equivalent to: `return append(il.begin(), il.size());`
 ``` cpp
+constexpr void push_back(charT c);
 ```
+*Effects:* Equivalent to `append(size_type{1}, c)`.
 ##### `basic_string::assign` <a id="string.assign">[[string.assign]]</a>
 ``` cpp
+constexpr basic_string& assign(const basic_string& str);
 ```
+*Effects:* Equivalent to: `return *this = str;`
 ``` cpp
+constexpr basic_string& assign(basic_string&& str)
   noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
+*Effects:* Equivalent to: `return *this = std::move(str);`
 ``` cpp
+constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+return assign(basic_string_view<charT, traits>(str).substr(pos, n));
 ```
 ``` cpp
 template<class T>
+ constexpr basic_string& assign(const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+ `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return assign(sv.data(), sv.size());
+```
 ``` cpp
+template<class T>
+  constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return assign(sv.substr(pos, n));
+```
 ``` cpp
+constexpr basic_string& assign(const charT* s, size_type n);
 ```
+*Preconditions:* \[`s`, `s + n`) is a valid range.
+*Effects:* Replaces the string controlled by `*this` with a copy of the
+range \[`s`, `s + n`).
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& assign(const charT* s);
 ```
+*Effects:* Equivalent to: `return assign(s, traits::length(s));`
+``` cpp
+constexpr basic_string& assign(initializer_list<charT> il);
+```
+*Effects:* Equivalent to: `return assign(il.begin(), il.size());`
 ``` cpp
+constexpr basic_string& assign(size_type n, charT c);
 ```
+*Effects:* Equivalent to:
+``` cpp
+clear();
+resize(n, c);
+return *this;
+```
 ``` cpp
 template<class InputIterator>
+ constexpr basic_string& assign(InputIterator first, InputIterator last);
 ```
+*Constraints:* `InputIterator` is a type that qualifies as an input
+iterator [[container.requirements.general]].
+*Effects:* Equivalent to:
+`return assign(basic_string(first, last, get_allocator()));`
 ##### `basic_string::insert` <a id="string.insert">[[string.insert]]</a>
 ``` cpp
+constexpr basic_string& insert(size_type pos, const basic_string& str);
 ```
 *Effects:* Equivalent to: `return insert(pos, str.data(), str.size());`
 ``` cpp
+constexpr basic_string& insert(size_type pos1, const basic_string& str,
                                size_type pos2, size_type n = npos);
 ```
+*Effects:* Equivalent to:
+``` cpp
+return insert(pos1, basic_string_view<charT, traits>(str), pos2, n);
+```
 ``` cpp
+template<class T>
+  constexpr basic_string& insert(size_type pos, const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return insert(pos, sv.data(), sv.size());
+```
 ``` cpp
 template<class T>
+ constexpr basic_string& insert(size_type pos1, const T& t,
                                  size_type pos2, size_type n = npos);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+ `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return insert(pos1, sv.substr(pos2, n));
+```
 ``` cpp
+constexpr basic_string& insert(size_type pos, const charT* s, size_type n);
 ```
+*Preconditions:* \[`s`, `s + n`) is a valid range.
+*Throws:*
+- `out_of_range` if `pos > size()`,
+- `length_error` if `n > max_size() - size()`, or
+- any exceptions thrown by `allocator_traits<Allocator>::allocate`.
+*Effects:* Inserts a copy of the range \[`s`, `s + n`) immediately
+before the character at position `pos` if `pos < size()`, or otherwise
+at the end of the string.
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& insert(size_type pos, const charT* s);
 ```
 *Effects:* Equivalent to: `return insert(pos, s, traits::length(s));`
 ``` cpp
+constexpr basic_string& insert(size_type pos, size_type n, charT c);
 ```
+*Effects:* Inserts `n` copies of `c` before the character at position
+`pos` if `pos < size()`, or otherwise at the end of the string.
+*Returns:* `*this`
+*Throws:*
+- `out_of_range` if `pos > size()`,
+- `length_error` if `n > max_size() - size()`, or
+- any exceptions thrown by `allocator_traits<Allocator>::allocate`.
 ``` cpp
+constexpr iterator insert(const_iterator p, charT c);
 ```
+*Preconditions:* `p` is a valid iterator on `*this`.
+*Effects:* Inserts a copy of `c` at the position `p`.
+*Returns:* An iterator which refers to the inserted character.
 ``` cpp
+constexpr iterator insert(const_iterator p, size_type n, charT c);
 ```
+*Preconditions:* `p` is a valid iterator on `*this`.
+*Effects:* Inserts `n` copies of `c` at the position `p`.
+*Returns:* An iterator which refers to the first inserted character, or
+`p` if `n == 0`.
 ``` cpp
 template<class InputIterator>
+ constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
 ```
+*Constraints:* `InputIterator` is a type that qualifies as an input
+iterator [[container.requirements.general]].
+*Preconditions:* `p` is a valid iterator on `*this`.
 *Effects:* Equivalent to
 `insert(p - begin(), basic_string(first, last, get_allocator()))`.
+*Returns:* An iterator which refers to the first inserted character, or
+`p` if `first == last`.
 ``` cpp
+constexpr iterator insert(const_iterator p, initializer_list<charT> il);
 ```
+*Effects:* Equivalent to: `return insert(p, il.begin(), il.end());`
 ##### `basic_string::erase` <a id="string.erase">[[string.erase]]</a>
 ``` cpp
+constexpr basic_string& erase(size_type pos = 0, size_type n = npos);
 ```
 *Throws:* `out_of_range` if `pos` `> size()`.
 *Effects:* Determines the effective length `xlen` of the string to be
+removed as the smaller of `n` and `size() - pos`. Removes the characters
+in the range \[`begin() + pos`, `begin() + pos + xlen`).
 *Returns:* `*this`.
 ``` cpp
+constexpr iterator erase(const_iterator p);
 ```
+*Preconditions:* `p` is a valid dereferenceable iterator on `*this`.
 *Throws:* Nothing.
 *Effects:* Removes the character referred to by `p`.
 *Returns:* An iterator which points to the element immediately following
 `p` prior to the element being erased. If no such element exists,
 `end()` is returned.
 ``` cpp
+constexpr iterator erase(const_iterator first, const_iterator last);
 ```
+*Preconditions:* `first` and `last` are valid iterators on `*this`.
+\[`first`, `last`) is a valid range.
 *Throws:* Nothing.
 *Effects:* Removes the characters in the range `[first, last)`.
 *Returns:* An iterator which points to the element pointed to by `last`
 prior to the other elements being erased. If no such element exists,
 `end()` is returned.
 ``` cpp
+constexpr void pop_back();
 ```
+*Preconditions:* `!empty()`.
 *Throws:* Nothing.
+*Effects:* Equivalent to `erase(end() - 1)`.
 ##### `basic_string::replace` <a id="string.replace">[[string.replace]]</a>
 ``` cpp
+constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
 ```
 *Effects:* Equivalent to:
 `return replace(pos1, n1, str.data(), str.size());`
 ``` cpp
+constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
                                 size_type pos2, size_type n2 = npos);
 ```
+*Effects:* Equivalent to:
+``` cpp
+return replace(pos1, n1, basic_string_view<charT, traits>(str).substr(pos2, n2));
+```
 ``` cpp
+template<class T>
+  constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
 *Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return replace(pos1, n1, sv.data(), sv.size());
+```
 ``` cpp
 template<class T>
+ constexpr basic_string& replace(size_type pos1, size_type n1, const T& t,
                                   size_type pos2, size_type n2 = npos);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+ `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+return replace(pos1, n1, sv.substr(pos2, n2));
+```
 ``` cpp
+constexpr basic_string& replace(size_type pos1, size_type n1, const charT* s, size_type n2);
 ```
+*Preconditions:* \[`s`, `s + n2`) is a valid range.
+*Throws:*
+- `out_of_range` if `pos1 > size()`,
+- `length_error` if the length of the resulting string would exceed
+  `max_size()` (see below), or
+- any exceptions thrown by `allocator_traits<Allocator>::allocate`.
 *Effects:* Determines the effective length `xlen` of the string to be
 removed as the smaller of `n1` and `size() - pos1`. If
 `size() - xlen >= max_size() - n2` throws `length_error`. Otherwise, the
+function replaces the characters in the range \[`begin() + pos1`,
+`begin() + pos1 + xlen`) with a copy of the range \[`s`, `s + n2`).
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& replace(size_type pos, size_type n, const charT* s);
 ```
 *Effects:* Equivalent to:
 `return replace(pos, n, s, traits::length(s));`
 ``` cpp
+constexpr basic_string& replace(size_type pos1, size_type n1, size_type n2, charT c);
 ```
+*Throws:*
+- `out_of_range` if `pos1 > size()`,
+- `length_error` if the length of the resulting string would exceed
+  `max_size()` (see below), or
+- any exceptions thrown by `allocator_traits<Allocator>::allocate.`
+*Effects:* Determines the effective length `xlen` of the string to be
+removed as the smaller of `n1` and `size() - pos1`. If
+`size() - xlen >=` `max_size() - n2` throws `length_error`. Otherwise,
+the function replaces the characters in the range \[`begin() + pos1`,
+`begin() + pos1 + xlen`) with `n2` copies of `c`.
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
 ```
+*Effects:* Equivalent to:
+`return replace(i1, i2, basic_string_view<charT, traits>(str));`
 ``` cpp
+template<class T>
+  constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Preconditions:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
+*Effects:* Equivalent to:
 ``` cpp
+basic_string_view<charT, traits> sv = t;
+return replace(i1 - begin(), i2 - i1, sv.data(), sv.size());
 ```
 ``` cpp
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
 ```
+*Effects:* Equivalent to:
+`return replace(i1, i2, basic_string_view<charT, traits>(s, n));`
+``` cpp
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
+```
+*Effects:* Equivalent to:
+`return replace(i1, i2, basic_string_view<charT, traits>(s));`
 ``` cpp
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);
 ```
+*Preconditions:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
+*Effects:* Equivalent to: `return replace(i1 - begin(), i2 - i1, n, c);`
 ``` cpp
 template<class InputIterator>
+ constexpr basic_string& replace(const_iterator i1, const_iterator i2,
                                   InputIterator j1, InputIterator j2);
 ```
+*Constraints:* `InputIterator` is a type that qualifies as an input
+iterator [[container.requirements.general]].
+*Effects:* Equivalent to:
+`return replace(i1, i2, basic_string(j1, j2, get_allocator()));`
 ``` cpp
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il);
 ```
+*Effects:* Equivalent to:
+`return replace(i1, i2, il.begin(), il.size());`
 ##### `basic_string::copy` <a id="string.copy">[[string.copy]]</a>
 ``` cpp
+constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
 ```
+*Effects:* Equivalent to:
+`return basic_string_view<charT, traits>(*this).copy(s, n, pos);`
 [*Note 1*: This does not terminate `s` with a null
 object. — *end note*]
 ##### `basic_string::swap` <a id="string.swap">[[string.swap]]</a>
 ``` cpp
+constexpr void swap(basic_string& s)
   noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
+*Preconditions:*
+`allocator_traits<Allocator>::propagate_on_container_swap::value` is
+`true` or `get_allocator() == s.get_allocator()`.
+*Ensures:* `*this` contains the same sequence of characters that was in
+`s`, `s` contains the same sequence of characters that was in `*this`.
 *Throws:* Nothing.
 *Complexity:* Constant time.
+#### String operations <a id="string.ops">[[string.ops]]</a>
+##### Accessors <a id="string.accessors">[[string.accessors]]</a>
 ``` cpp
+constexpr const charT* c_str() const noexcept;
+constexpr const charT* data() const noexcept;
 ```
+*Returns:* A pointer `p` such that `p + i == addressof(operator[](i))`
+for each `i` in \[`0`, `size()`\].
 *Complexity:* Constant time.
+*Remarks:* The program shall not modify any of the values stored in the
+character array; otherwise, the behavior is undefined.
 ``` cpp
+constexpr charT* data() noexcept;
 ```
+*Returns:* A pointer `p` such that `p + i == addressof(operator[](i))`
+for each `i` in \[`0`, `size()`\].
 *Complexity:* Constant time.
+*Remarks:* The program shall not modify the value stored at `p + size()`
+to any value other than `charT()`; otherwise, the behavior is undefined.
 ``` cpp
+constexpr operator basic_string_view<charT, traits>() const noexcept;
 ```
 *Effects:* Equivalent to:
 `return basic_string_view<charT, traits>(data(), size());`
 ``` cpp
+constexpr allocator_type get_allocator() const noexcept;
 ```
 *Returns:* A copy of the `Allocator` object used to construct the string
 or, if that allocator has been replaced, a copy of the most recent
 replacement.
+##### Searching <a id="string.find">[[string.find]]</a>
+Let *F* be one of `find`, `rfind`, `find_first_of`, `find_last_of`,
+`find_first_not_of`, and `find_last_not_of`.
+- Each member function of the form
   ``` cpp
+  constexpr size_type F(const basic_string& str, size_type pos) const noexcept;
   ```
+  has effects equivalent to:
+  `return F(basic_string_view<charT, traits>(str), pos);`
+- Each member function of the form
   ``` cpp
+  constexpr size_type F(const charT* s, size_type pos) const;
   ```
+  has effects equivalent to:
+  `return F(basic_string_view<charT, traits>(s), pos);`
+- Each member function of the form
   ``` cpp
+  constexpr size_type F(const charT* s, size_type pos, size_type n) const;
   ```
+  has effects equivalent to:
+  `return F(basic_string_view<charT, traits>(s, n), pos);`
+- Each member function of the form
   ``` cpp
+  constexpr size_type F(charT c, size_type pos) const noexcept;
   ```
+  has effects equivalent to:
   ``` cpp
+  return F(basic_string_view<charT, traits>(addressof(c), 1), pos);
   ```
 ``` cpp
+template<class T>
+  constexpr size_type find(const T& t, size_type pos = 0) const noexcept(see below);
+template<class T>
+  constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(see below);
+template<class T>
+  constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(see below);
+template<class T>
+  constexpr size_type find_last_of(const T& t, size_type pos = npos) const noexcept(see below);
+template<class T>
+  constexpr size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept(see below);
+template<class T>
+  constexpr size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept(see below);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+ `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Let *G* be the name of the function. Equivalent to:
 ``` cpp
+basic_string_view<charT, traits> s = *this, sv = t;
+return s.G(sv, pos);
 ```
+*Remarks:* The expression inside `noexcept` is equivalent to
+`is_nothrow_convertible_v<const T&, basic_string_view<charT, traits>>`.
 ##### `basic_string::substr` <a id="string.substr">[[string.substr]]</a>
 ``` cpp
+constexpr basic_string substr(size_type pos = 0, size_type n = npos) const;
 ```
 *Throws:* `out_of_range` if `pos > size()`.
 *Effects:* Determines the effective length `rlen` of the string to copy
 *Returns:* `basic_string(data()+pos, rlen)`.
 ##### `basic_string::compare` <a id="string.compare">[[string.compare]]</a>
 ``` cpp
+template<class T>
+  constexpr int compare(const T& t) const noexcept(see below);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+`return basic_string_view<charT, traits>(*this).compare(t);`
+*Remarks:* The expression inside `noexcept` is equivalent to
+`is_nothrow_convertible_v<const T&, basic_string_view<charT, traits>>`.
 ``` cpp
+template<class T>
+  constexpr int compare(size_type pos1, size_type n1, const T& t) const;
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
 *Effects:* Equivalent to:
 ``` cpp
+return basic_string_view<charT, traits>(*this).substr(pos1, n1).compare(t);
 ```
 ``` cpp
 template<class T>
+ constexpr int compare(size_type pos1, size_type n1, const T& t,
                         size_type pos2, size_type n2 = npos) const;
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
 *Effects:* Equivalent to:
 ``` cpp
+basic_string_view<charT, traits> s = *this, sv = t;
+return s.substr(pos1, n1).compare(sv.substr(pos2, n2));
 ```
 ``` cpp
+constexpr int compare(const basic_string& str) const noexcept;
 ```
 *Effects:* Equivalent to:
 `return compare(basic_string_view<charT, traits>(str));`
 ``` cpp
+constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
 ```
 *Effects:* Equivalent to:
 `return compare(pos1, n1, basic_string_view<charT, traits>(str));`
 ``` cpp
+constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
                       size_type pos2, size_type n2 = npos) const;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return compare(pos1, n1, basic_string_view<charT, traits>(str), pos2, n2);
 ```
 ``` cpp
+constexpr int compare(const charT* s) const;
 ```
+*Effects:* Equivalent to:
+`return compare(basic_string_view<charT, traits>(s));`
 ``` cpp
+constexpr int compare(size_type pos, size_type n1, const charT* s) const;
 ```
+*Effects:* Equivalent to:
+`return compare(pos, n1, basic_string_view<charT, traits>(s));`
 ``` cpp
+constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
 ```
+*Effects:* Equivalent to:
+`return compare(pos, n1, basic_string_view<charT, traits>(s, n2));`
+##### `basic_string::starts_with` <a id="string.starts.with">[[string.starts.with]]</a>
 ``` cpp
+constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
+constexpr bool starts_with(charT x) const noexcept;
+constexpr bool starts_with(const charT* x) const;
 ```
+*Effects:* Equivalent to:
 ``` cpp
+return basic_string_view<charT, traits>(data(), size()).starts_with(x);
 ```
+##### `basic_string::ends_with` <a id="string.ends.with">[[string.ends.with]]</a>
 ``` cpp
+constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
+constexpr bool ends_with(charT x) const noexcept;
+constexpr bool ends_with(const charT* x) const;
 ```
+*Effects:* Equivalent to:
 ``` cpp
+return basic_string_view<charT, traits>(data(), size()).ends_with(x);
 ```
+### Non-member functions <a id="string.nonmembers">[[string.nonmembers]]</a>
+#### `operator+` <a id="string.op.plus">[[string.op.plus]]</a>
 ``` cpp
 template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
+    operator+(const basic_string<charT, traits, Allocator>& lhs,
               const basic_string<charT, traits, Allocator>& rhs);
+template<class charT, class traits, class Allocator>
+  constexpr basic_string<charT, traits, Allocator>
+    operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+basic_string<charT, traits, Allocator> r = lhs;
+r.append(rhs);
+return r;
 ```
 ``` cpp
 template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
+    operator+(basic_string<charT, traits, Allocator>&& lhs,
               const basic_string<charT, traits, Allocator>& rhs);
 template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
+    operator+(basic_string<charT, traits, Allocator>&& lhs, const charT* rhs);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+lhs.append(rhs);
+return std::move(lhs);
 ```
 ``` cpp
 template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
     operator+(basic_string<charT, traits, Allocator>&& lhs,
+ basic_string<charT, traits, Allocator>&& rhs);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+lhs.append(rhs);
+return std::move(lhs);
 ```
+except that both `lhs` and `rhs` are left in valid but unspecified
+states.
+[*Note 1*: If `lhs` and `rhs` have equal allocators, the implementation
+may move from either. — *end note*]
 ``` cpp
 template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
+    operator+(const basic_string<charT, traits, Allocator>& lhs,
+              basic_string<charT, traits, Allocator>&& rhs);
 template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
+    operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+rhs.insert(0, lhs);
+return std::move(rhs);
 ```
 ``` cpp
 template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
+    operator+(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+basic_string<charT, traits, Allocator> r = rhs;
+r.insert(0, lhs);
+return r;
 ```
 ``` cpp
 template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
+    operator+(charT lhs, const basic_string<charT, traits, Allocator>& rhs);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+basic_string<charT, traits, Allocator> r = rhs;
+r.insert(r.begin(), lhs);
+return r;
 ```
 ``` cpp
 template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
+    operator+(charT lhs, basic_string<charT, traits, Allocator>&& rhs);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+rhs.insert(rhs.begin(), lhs);
+return std::move(rhs);
 ```
 ``` cpp
 template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
+    operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+basic_string<charT, traits, Allocator> r = lhs;
+r.push_back(rhs);
+return r;
 ```
 ``` cpp
 template<class charT, class traits, class Allocator>
+ constexpr basic_string<charT, traits, Allocator>
+    operator+(basic_string<charT, traits, Allocator>&& lhs, charT rhs);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+lhs.push_back(rhs);
+return std::move(lhs);
 ```
+#### Non-member comparison functions <a id="string.cmp">[[string.cmp]]</a>
 ``` cpp
 template<class charT, class traits, class Allocator>
+ constexpr bool
+    operator==(const basic_string<charT, traits, Allocator>& lhs,
+               const basic_string<charT, traits, Allocator>& rhs) noexcept;
 template<class charT, class traits, class Allocator>
+ constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
                             const charT* rhs);
 template<class charT, class traits, class Allocator>
+ constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
+            \itcorr                      const basic_string<charT, traits, Allocator>& rhs) noexcept;
 template<class charT, class traits, class Allocator>
+ constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
+            \itcorr                      const charT* rhs);
 ```
+*Effects:* Let *`op`* be the operator. Equivalent to:
 ``` cpp
+return basic_string_view<charT, traits>(lhs) op basic_string_view<charT, traits>(rhs);
 ```
 #### `swap` <a id="string.special">[[string.special]]</a>
 ``` cpp
 template<class charT, class traits, class Allocator>
+ constexpr void
+    swap(basic_string<charT, traits, Allocator>& lhs,
          basic_string<charT, traits, Allocator>& rhs)
       noexcept(noexcept(lhs.swap(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
 After the last character (if any) is extracted, `is.width(0)` is called
 and the `sentry` object 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_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 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_string<charT, traits, Allocator>& str);
 ```
 *Returns:* `getline(is, str, is.widen(’\n’))`.
+#### Erasure <a id="string.erasure">[[string.erasure]]</a>
+``` cpp
+template<class charT, class traits, class Allocator, class U>
+  constexpr typename basic_string<charT, traits, Allocator>::size_type
+    erase(basic_string<charT, traits, Allocator>& c, const U& value);
+```
+*Effects:* Equivalent to:
+``` cpp
+auto it = remove(c.begin(), c.end(), value);
+auto r = distance(it, c.end());
+c.erase(it, c.end());
+return r;
+```
+``` cpp
+template<class charT, class traits, class Allocator, class Predicate>
+  constexpr typename basic_string<charT, traits, Allocator>::size_type
+    erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred);
+```
+*Effects:* Equivalent to:
+``` cpp
+auto it = remove_if(c.begin(), c.end(), pred);
+auto r = distance(it, c.end());
+c.erase(it, c.end());
+return r;
+```
 ### Numeric conversions <a id="string.conversions">[[string.conversions]]</a>
 ``` cpp
+int stoi(const string& str, size_t* idx = nullptr, int base = 10);
+long stol(const string& str, size_t* idx = nullptr, int base = 10);
+unsigned long stoul(const string& str, size_t* idx = nullptr, int base = 10);
+long long stoll(const string& str, size_t* idx = nullptr, int base = 10);
+unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);
 ```
+*Effects:* The first two functions call
 `strtol(str.c_str(), ptr, base)`, and the last three functions call
 `strtoul(str.c_str(), ptr, base)`, `strtoll(str.c_str(), ptr, base)`,
 and `strtoull(str.c_str(), ptr, base)`, respectively. Each function
 returns the converted result, if any. The argument `ptr` designates a
 pointer to an object internal to the function that is used to determine
 `out_of_range` if `strtol`, `strtoul`, `strtoll` or `strtoull` sets
 `errno` to `ERANGE`, or if the converted value is outside the range of
 representable values for the return type.
 ``` cpp
+float stof(const string& str, size_t* idx = nullptr);
+double stod(const string& str, size_t* idx = nullptr);
+long double stold(const string& str, size_t* idx = nullptr);
 ```
 *Effects:* These functions call `strtof(str.c_str(), ptr)`,
 `strtod(str.c_str(), ptr)`, and `strtold(str.c_str(), ptr)`,
 respectively. Each function returns the converted result, if any. The
 `"%u"`, `"%ld"`, `"%lu"`, `"%lld"`, `"%llu"`, `"%f"`, `"%f"`, or
 `"%Lf"`, respectively, where `buf` designates an internal character
 buffer of sufficient size.
 ``` cpp
+int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);
+long stol(const wstring& str, size_t* idx = nullptr, int base = 10);
+unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);
+long long stoll(const wstring& str, size_t* idx = nullptr, int base = 10);
+unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);
 ```
+*Effects:* The first two functions call
 `wcstol(str.c_str(), ptr, base)`, and the last three functions call
 `wcstoul(str.c_str(), ptr, base)`, `wcstoll(str.c_str(), ptr, base)`,
 and `wcstoull(str.c_str(), ptr, base)`, respectively. Each function
 returns the converted result, if any. The argument `ptr` designates a
 pointer to an object internal to the function that is used to determine
 `wcstoull` reports that no conversion could be performed. Throws
 `out_of_range` if the converted value is outside the range of
 representable values for the return type.
 ``` cpp
+float stof(const wstring& str, size_t* idx = nullptr);
+double stod(const wstring& str, size_t* idx = nullptr);
+long double stold(const wstring& str, size_t* idx = nullptr);
 ```
 *Effects:* These functions call `wcstof(str.c_str(), ptr)`,
 `wcstod(str.c_str(), ptr)`, and `wcstold(str.c_str(), ptr)`,
 respectively. Each function returns the converted result, if any. The
 ### Hash support <a id="basic.string.hash">[[basic.string.hash]]</a>
 ``` cpp
 template<> struct hash<string>;
+template<> struct hash<u8string>;
 template<> struct hash<u16string>;
 template<> struct hash<u32string>;
 template<> struct hash<wstring>;
+template<> struct hash<pmr::string>;
+template<> struct hash<pmr::u8string>;
+template<> struct hash<pmr::u16string>;
+template<> struct hash<pmr::u32string>;
+template<> struct hash<pmr::wstring>;
 ```
 If `S` is one of these string types, `SV` is the corresponding string
 view type, and `s` is an object of type `S`, then
 `hash<S>()(s) == hash<SV>()(SV(s))`.
 ### Suffix for `basic_string` literals <a id="basic.string.literals">[[basic.string.literals]]</a>
 ``` cpp
+constexpr string operator""s(const char* str, size_t len);
 ```
 *Returns:* `string{str, len}`.
 ``` cpp
+constexpr u8string operator""s(const char8_t* str, size_t len);
+```
+*Returns:* `u8string{str, len}`.
+``` cpp
+constexpr u16string operator""s(const char16_t* str, size_t len);
 ```
 *Returns:* `u16string{str, len}`.
 ``` cpp
+constexpr u32string operator""s(const char32_t* str, size_t len);
 ```
 *Returns:* `u32string{str, len}`.
 ``` cpp
+constexpr wstring operator""s(const wchar_t* str, size_t len);
 ```
 *Returns:* `wstring{str, len}`.
 [*Note 1*: The same suffix `s` is used for `chrono::duration` literals

Diff to HTML by rtfpessoa