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

Files changed (1) hide show

tmp/tmp3ehaz_90/{from.md → to.md} +95 -100

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

@@ -1,33 +1,31 @@
 ### Class template `list` <a id="list">[[list]]</a>
-#### Class template `list` overview <a id="list.overview">[[list.overview]]</a>
 A `list` is a sequence container that supports bidirectional iterators
 and allows constant time insert and erase operations anywhere within the
-sequence, with storage management handled automatically. Unlike
-vectors ([[vector]]) and deques ([[deque]]), fast random access to
-list elements is not supported, but many algorithms only need sequential
-access anyway.
-A `list` satisfies all of the requirements of a container, of a
-reversible container (given in two tables in
-[[container.requirements]]), of a sequence container, including most of
-the optional sequence container requirements ([[sequence.reqmts]]), and
-of an allocator-aware container (Table
-[[tab:containers.allocatoraware]]). The exceptions are the `operator[]`
-and `at` member functions, which are not provided.[^2] Descriptions are
-provided here only for operations on `list` that are not described in
-one of these tables or for operations where there is additional semantic
 information.
 ``` cpp
 namespace std {
   template<class T, class Allocator = allocator<T>>
   class list {
   public:
-    // types:
     using value_type             = T;
     using allocator_type         = Allocator;
     using pointer                = typename allocator_traits<Allocator>::pointer;
     using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
@@ -60,11 +58,11 @@ namespace std {
       void assign(InputIterator first, InputIterator last);
     void assign(size_type n, const T& t);
     void assign(initializer_list<T>);
     allocator_type get_allocator() const noexcept;
-    // iterators:
     iterator               begin() noexcept;
     const_iterator         begin() const noexcept;
     iterator               end() noexcept;
     const_iterator         end() const noexcept;
     reverse_iterator       rbegin() noexcept;
@@ -76,17 +74,17 @@ namespace std {
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
     // [list.capacity], capacity
-    bool empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
     void      resize(size_type sz);
     void      resize(size_type sz, const T& c);
-    // element access:
     reference       front();
     const_reference front() const;
     reference       back();
     const_reference back() const;
@@ -103,36 +101,32 @@ namespace std {
     template<class... Args> iterator emplace(const_iterator position, Args&&... args);
     iterator insert(const_iterator position, const T& x);
     iterator insert(const_iterator position, T&& x);
     iterator insert(const_iterator position, size_type n, const T& x);
     template<class InputIterator>
-      iterator insert(const_iterator position, InputIterator first,
-                      InputIterator last);
     iterator insert(const_iterator position, initializer_list<T> il);
     iterator erase(const_iterator position);
     iterator erase(const_iterator position, const_iterator last);
-    void     swap(list&)
-      noexcept(allocator_traits<Allocator>::is_always_equal::value);
     void     clear() noexcept;
     // [list.ops], list operations
     void splice(const_iterator position, list& x);
     void splice(const_iterator position, list&& x);
     void splice(const_iterator position, list& x, const_iterator i);
     void splice(const_iterator position, list&& x, const_iterator i);
-    void splice(const_iterator position, list& x,
- const_iterator first, const_iterator last);
-    void splice(const_iterator position, list&& x,
-                const_iterator first, const_iterator last);
- void remove(const T& value);
-    template <class Predicate> void remove_if(Predicate pred);
- void unique();
     template<class BinaryPredicate>
- void unique(BinaryPredicate binary_pred);
     void merge(list& x);
     void merge(list&& x);
     template<class Compare> void merge(list& x, Compare comp);
     template<class Compare> void merge(list&& x, Compare comp);
@@ -141,41 +135,27 @@ namespace std {
     template<class Compare> void sort(Compare comp);
     void reverse() noexcept;
   };
-  template<class InputIterator,
-           class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
     list(InputIterator, InputIterator, Allocator = Allocator())
-      -> list<typename iterator_traits<InputIterator>::value_type, Allocator>;
- template <class T, class Allocator>
-    bool operator==(const list<T, Allocator>& x, const list<T, Allocator>& y);
-  template <class T, class Allocator>
-    bool operator< (const list<T, Allocator>& x, const list<T, Allocator>& y);
-  template <class T, class Allocator>
-    bool operator!=(const list<T, Allocator>& x, const list<T, Allocator>& y);
-  template <class T, class Allocator>
-    bool operator> (const list<T, Allocator>& x, const list<T, Allocator>& y);
-  template <class T, class Allocator>
-    bool operator>=(const list<T, Allocator>& x, const list<T, Allocator>& y);
-  template <class T, class Allocator>
-    bool operator<=(const list<T, Allocator>& x, const list<T, Allocator>& y);
-  // [list.special], specialized algorithms
   template<class T, class Allocator>
     void swap(list<T, Allocator>& x, list<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
 }
 ```
 An incomplete type `T` may be used when instantiating `list` if the
-allocator satisfies the allocator completeness requirements (
-[[allocator.requirements.completeness]]). `T` shall be complete before
 any member of the resulting specialization of `list` is referenced.
-#### `list` constructors, copy, and assignment <a id="list.cons">[[list.cons]]</a>
 ``` cpp
 explicit list(const Allocator&);
 ```
@@ -185,26 +165,26 @@ explicit list(const Allocator&);
 ``` cpp
 explicit list(size_type n, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `list` with `n` default-inserted elements using
 the specified allocator.
-*Requires:* `T` shall be `DefaultInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
 list(size_type n, const T& value, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `list` with `n` copies of `value`, using the
 specified allocator.
-*Requires:* `T` shall be `CopyInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
 template<class InputIterator>
   list(InputIterator first, InputIterator last, const Allocator& = Allocator());
@@ -212,31 +192,33 @@ template <class InputIterator>
 *Effects:* Constructs a `list` equal to the range \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
-#### `list` capacity <a id="list.capacity">[[list.capacity]]</a>
 ``` cpp
 void resize(size_type sz);
 ```
 *Effects:* If `size() < sz`, appends `sz - size()` default-inserted
 elements to the sequence. If `sz <= size()`, equivalent to:
 ``` cpp
 list<T>::iterator it = begin();
 advance(it, sz);
 erase(it, end());
 ```
-*Requires:* `T` shall be `DefaultInsertable` into `*this`.
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
 *Effects:* As if by:
 ``` cpp
 if (sz > size())
   insert(end(), sz-size(), c);
@@ -247,13 +229,11 @@ else if (sz < size()) {
 }
 else
   ;                 // do nothing
 ```
-*Requires:* `T` shall be `CopyInsertable` into `*this`.
-#### `list` modifiers <a id="list.modifiers">[[list.modifiers]]</a>
 ``` cpp
 iterator insert(const_iterator position, const T& x);
 iterator insert(const_iterator position, T&& x);
 iterator insert(const_iterator position, size_type n, const T& x);
@@ -297,14 +277,18 @@ elements.
 *Complexity:* Erasing a single element is a constant time operation with
 a single call to the destructor of `T`. Erasing a range in a list is
 linear time in the size of the range and the number of calls to the
 destructor of type `T` is exactly equal to the size of the range.
-#### `list` operations <a id="list.ops">[[list.ops]]</a>
 Since lists allow fast insertion and erasing from the middle of a list,
-certain operations are provided specifically for them.[^3]
 `list` provides three splice operations that destructively move elements
 from one list to another. The behavior of splice operations is undefined
 if `get_allocator() !=
 x.get_allocator()`.
@@ -312,11 +296,11 @@ x.get_allocator()`.
 ``` cpp
 void splice(const_iterator position, list& x);
 void splice(const_iterator position, list&& x);
 ```
-*Requires:* `&x != this`.
 *Effects:* Inserts the contents of `x` before `position` and `x` becomes
 empty. Pointers and references to the moved elements of `x` now refer to
 those same elements but as members of `*this`. Iterators referring to
 the moved elements will continue to refer to their elements, but they
@@ -329,11 +313,11 @@ now behave as iterators into `*this`, not into `x`.
 ``` cpp
 void splice(const_iterator position, list& x, const_iterator i);
 void splice(const_iterator position, list&& x, const_iterator i);
 ```
-*Requires:* `i` is a valid dereferenceable iterator of `x`.
 *Effects:* Inserts an element pointed to by `i` from list `x` before
 `position` and removes the element from `x`. The result is unchanged if
 `position == i` or `position == ++i`. Pointers and references to `*i`
 continue to refer to this same element but as a member of `*this`.
@@ -349,55 +333,59 @@ void splice(const_iterator position, list& x, const_iterator first,
             const_iterator last);
 void splice(const_iterator position, list&& x, const_iterator first,
             const_iterator last);
 ```
-*Requires:* `[first, last)` is a valid range in `x`. The program has
-undefined behavior if `position` is an iterator in the range \[`first`,
-`last`).
 *Effects:* Inserts elements in the range \[`first`, `last`) before
 `position` and removes the elements from `x`. Pointers and references to
 the moved elements of `x` now refer to those same elements but as
 members of `*this`. Iterators referring to the moved elements will
 continue to refer to their elements, but they now behave as iterators
 into `*this`, not into `x`.
 *Throws:* Nothing.
-*Complexity:* Constant time if `&x == this`; otherwise, linear time.
 ``` cpp
-void remove(const T& value);
-template <class Predicate> void remove_if(Predicate pred);
 ```
-*Effects:* Erases all the elements in the list referred by a list
-iterator `i` for which the following conditions hold:
-`*i == value, pred(*i) != false`. Invalidates only the iterators and
-references to the erased elements.
 *Throws:* Nothing unless an exception is thrown by `*i == value` or
 `pred(*i) != false`.
-*Remarks:* Stable ([[algorithm.stable]]).
 *Complexity:* Exactly `size()` applications of the corresponding
 predicate.
 ``` cpp
-void unique();
-template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);
 ```
 *Effects:* Erases all but the first element from every consecutive group
 of equal elements referred to by the iterator `i` in the range
 \[`first + 1`, `last`) for which `*i == *(i-1)` (for the version of
 `unique` with no arguments) or `pred(*i, *(i - 1))` (for the version of
 `unique` with a predicate argument) holds. Invalidates only the
 iterators and references to the erased elements.
 *Throws:* Nothing unless an exception is thrown by `*i == *(i-1)` or
 `pred(*i, *(i - 1))`
 *Complexity:* If the range `[first, last)` is not empty, exactly
 `(last - first) - 1` applications of the corresponding predicate,
@@ -408,33 +396,34 @@ void merge(list& x);
 void merge(list&& x);
 template<class Compare> void merge(list& x, Compare comp);
 template<class Compare> void merge(list&& x, Compare comp);
 ```
-*Requires:* `comp` shall define a strict weak
-ordering ([[alg.sorting]]), and both the list and the argument list
-shall be sorted according to this ordering.
-*Effects:* If `(&x == this)` does nothing; otherwise, merges the two
-sorted ranges `[begin(), end())` and `[x.begin(), x.end())`. The result
-is a range in which the elements will be sorted in non-decreasing order
-according to the ordering defined by `comp`; that is, for every iterator
-`i`, in the range other than the first, the condition
 `comp(*i, *(i - 1))` will be `false`. Pointers and references to the
 moved elements of `x` now refer to those same elements but as members of
 `*this`. Iterators referring to the moved elements will continue to
 refer to their elements, but they now behave as iterators into `*this`,
 not into `x`.
-*Remarks:* Stable ([[algorithm.stable]]). If `(&x != this)` the range
-`[x.begin(), x.end())` is empty after the merge. No elements are copied
-by this operation. The behavior is undefined if
-`get_allocator() != x.get_allocator()`.
 *Complexity:* At most `size() + x.size() - 1` applications of `comp` if
-`(&x != this)`; otherwise, no applications of `comp` are performed. If
-an exception is thrown other than by a comparison there are no effects.
 ``` cpp
 void reverse() noexcept;
 ```
@@ -446,27 +435,33 @@ affect the validity of iterators and references.
 ``` cpp
 void sort();
 template<class Compare> void sort(Compare comp);
 ```
-*Requires:* `operator<` (for the first version) or `comp` (for the
-second version) shall define a strict weak ordering ([[alg.sorting]]).
 *Effects:* Sorts the list according to the `operator<` or a `Compare`
 function object. If an exception is thrown, the order of the elements in
 `*this` is unspecified. Does not affect the validity of iterators and
 references.
-*Remarks:* Stable ([[algorithm.stable]]).
 *Complexity:* Approximately N log N comparisons, where `N == size()`.
-#### `list` specialized algorithms <a id="list.special">[[list.special]]</a>
 ``` cpp
-template <class T, class Allocator>
- void swap(list<T, Allocator>& x, list<T, Allocator>& y)
- noexcept(noexcept(x.swap(y)));
 ```
-*Effects:* As if by `x.swap(y)`.

 ### Class template `list` <a id="list">[[list]]</a>
+#### Overview <a id="list.overview">[[list.overview]]</a>
 A `list` is a sequence container that supports bidirectional iterators
 and allows constant time insert and erase operations anywhere within the
+sequence, with storage management handled automatically. Unlike vectors
+[[vector]] and deques [[deque]], fast random access to list elements is
+not supported, but many algorithms only need sequential access anyway.
+A `list` meets all of the requirements of a container, of a reversible
+container (given in two tables in [[container.requirements]]), of a
+sequence container, including most of the optional sequence container
+requirements [[sequence.reqmts]], and of an allocator-aware container (
+[[container.alloc.req]]). The exceptions are the `operator[]` and `at`
+member functions, which are not provided.[^2] Descriptions are provided
+here only for operations on `list` that are not described in one of
+these tables or for operations where there is additional semantic
 information.
 ``` cpp
 namespace std {
   template<class T, class Allocator = allocator<T>>
   class list {
   public:
+    // types
     using value_type             = T;
     using allocator_type         = Allocator;
     using pointer                = typename allocator_traits<Allocator>::pointer;
     using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
       void assign(InputIterator first, InputIterator last);
     void assign(size_type n, const T& t);
     void assign(initializer_list<T>);
     allocator_type get_allocator() const noexcept;
+    // iterators
     iterator               begin() noexcept;
     const_iterator         begin() const noexcept;
     iterator               end() noexcept;
     const_iterator         end() const noexcept;
     reverse_iterator       rbegin() noexcept;
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
     // [list.capacity], capacity
+ [[nodiscard]] bool empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
     void      resize(size_type sz);
     void      resize(size_type sz, const T& c);
+    // element access
     reference       front();
     const_reference front() const;
     reference       back();
     const_reference back() const;
     template<class... Args> iterator emplace(const_iterator position, Args&&... args);
     iterator insert(const_iterator position, const T& x);
     iterator insert(const_iterator position, T&& x);
     iterator insert(const_iterator position, size_type n, const T& x);
     template<class InputIterator>
+      iterator insert(const_iterator position, InputIterator first, InputIterator last);
     iterator insert(const_iterator position, initializer_list<T> il);
     iterator erase(const_iterator position);
     iterator erase(const_iterator position, const_iterator last);
+    void     swap(list&) noexcept(allocator_traits<Allocator>::is_always_equal::value);
     void     clear() noexcept;
     // [list.ops], list operations
     void splice(const_iterator position, list& x);
     void splice(const_iterator position, list&& x);
     void splice(const_iterator position, list& x, const_iterator i);
     void splice(const_iterator position, list&& x, const_iterator i);
+    void splice(const_iterator position, list& x, const_iterator first, const_iterator last);
+    void splice(const_iterator position, list&& x, const_iterator first, const_iterator last);
+ size_type remove(const T& value);
+    template<class Predicate> size_type remove_if(Predicate pred);
+ size_type unique();
     template<class BinaryPredicate>
+ size_type unique(BinaryPredicate binary_pred);
     void merge(list& x);
     void merge(list&& x);
     template<class Compare> void merge(list& x, Compare comp);
     template<class Compare> void merge(list&& x, Compare comp);
     template<class Compare> void sort(Compare comp);
     void reverse() noexcept;
   };
+  template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     list(InputIterator, InputIterator, Allocator = Allocator())
+      -> list<iter-value-type<InputIterator>, Allocator>;
+ // swap
   template<class T, class Allocator>
     void swap(list<T, Allocator>& x, list<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
 }
 ```
 An incomplete type `T` may be used when instantiating `list` if the
+allocator meets the allocator completeness requirements
+[[allocator.requirements.completeness]]. `T` shall be complete before
 any member of the resulting specialization of `list` is referenced.
+#### Constructors, copy, and assignment <a id="list.cons">[[list.cons]]</a>
 ``` cpp
 explicit list(const Allocator&);
 ```
 ``` cpp
 explicit list(size_type n, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `*this`.
 *Effects:* Constructs a `list` with `n` default-inserted elements using
 the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 list(size_type n, const T& value, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* Constructs a `list` with `n` copies of `value`, using the
 specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 template<class InputIterator>
   list(InputIterator first, InputIterator last, const Allocator& = Allocator());
 *Effects:* Constructs a `list` equal to the range \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
+#### Capacity <a id="list.capacity">[[list.capacity]]</a>
 ``` cpp
 void resize(size_type sz);
 ```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `*this`.
 *Effects:* If `size() < sz`, appends `sz - size()` default-inserted
 elements to the sequence. If `sz <= size()`, equivalent to:
 ``` cpp
 list<T>::iterator it = begin();
 advance(it, sz);
 erase(it, end());
 ```
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* As if by:
 ``` cpp
 if (sz > size())
   insert(end(), sz-size(), c);
 }
 else
   ;                 // do nothing
 ```
+#### Modifiers <a id="list.modifiers">[[list.modifiers]]</a>
 ``` cpp
 iterator insert(const_iterator position, const T& x);
 iterator insert(const_iterator position, T&& x);
 iterator insert(const_iterator position, size_type n, const T& x);
 *Complexity:* Erasing a single element is a constant time operation with
 a single call to the destructor of `T`. Erasing a range in a list is
 linear time in the size of the range and the number of calls to the
 destructor of type `T` is exactly equal to the size of the range.
+#### Operations <a id="list.ops">[[list.ops]]</a>
 Since lists allow fast insertion and erasing from the middle of a list,
+certain operations are provided specifically for them.[^3] In this
+subclause, arguments for a template parameter named `Predicate` or
+`BinaryPredicate` shall meet the corresponding requirements in
+[[algorithms.requirements]]. For `merge` and `sort`, the definitions and
+requirements in [[alg.sorting]] apply.
 `list` provides three splice operations that destructively move elements
 from one list to another. The behavior of splice operations is undefined
 if `get_allocator() !=
 x.get_allocator()`.
 ``` cpp
 void splice(const_iterator position, list& x);
 void splice(const_iterator position, list&& x);
 ```
+*Preconditions:* `addressof(x) != this` is `true`.
 *Effects:* Inserts the contents of `x` before `position` and `x` becomes
 empty. Pointers and references to the moved elements of `x` now refer to
 those same elements but as members of `*this`. Iterators referring to
 the moved elements will continue to refer to their elements, but they
 ``` cpp
 void splice(const_iterator position, list& x, const_iterator i);
 void splice(const_iterator position, list&& x, const_iterator i);
 ```
+*Preconditions:* `i` is a valid dereferenceable iterator of `x`.
 *Effects:* Inserts an element pointed to by `i` from list `x` before
 `position` and removes the element from `x`. The result is unchanged if
 `position == i` or `position == ++i`. Pointers and references to `*i`
 continue to refer to this same element but as a member of `*this`.
             const_iterator last);
 void splice(const_iterator position, list&& x, const_iterator first,
             const_iterator last);
 ```
+*Preconditions:* `[first, last)` is a valid range in `x`. `position` is
+not an iterator in the range \[`first`, `last`).
 *Effects:* Inserts elements in the range \[`first`, `last`) before
 `position` and removes the elements from `x`. Pointers and references to
 the moved elements of `x` now refer to those same elements but as
 members of `*this`. Iterators referring to the moved elements will
 continue to refer to their elements, but they now behave as iterators
 into `*this`, not into `x`.
 *Throws:* Nothing.
+*Complexity:* Constant time if `addressof(x) == this`; otherwise, linear
+time.
 ``` cpp
+size_type remove(const T& value);
+template<class Predicate> size_type remove_if(Predicate pred);
 ```
+*Effects:* Erases all the elements in the list referred to by a list
+iterator `i` for which the following conditions hold: `*i == value`,
+`pred(*i) != false`. Invalidates only the iterators and references to
+the erased elements.
+*Returns:* The number of elements erased.
 *Throws:* Nothing unless an exception is thrown by `*i == value` or
 `pred(*i) != false`.
+*Remarks:* Stable [[algorithm.stable]].
 *Complexity:* Exactly `size()` applications of the corresponding
 predicate.
 ``` cpp
+size_type unique();
+template<class BinaryPredicate> size_type unique(BinaryPredicate binary_pred);
 ```
 *Effects:* Erases all but the first element from every consecutive group
 of equal elements referred to by the iterator `i` in the range
 \[`first + 1`, `last`) for which `*i == *(i-1)` (for the version of
 `unique` with no arguments) or `pred(*i, *(i - 1))` (for the version of
 `unique` with a predicate argument) holds. Invalidates only the
 iterators and references to the erased elements.
+*Returns:* The number of elements erased.
 *Throws:* Nothing unless an exception is thrown by `*i == *(i-1)` or
 `pred(*i, *(i - 1))`
 *Complexity:* If the range `[first, last)` is not empty, exactly
 `(last - first) - 1` applications of the corresponding predicate,
 void merge(list&& x);
 template<class Compare> void merge(list& x, Compare comp);
 template<class Compare> void merge(list&& x, Compare comp);
 ```
+*Preconditions:* Both the list and the argument list shall be sorted
+with respect to the comparator `operator<` (for the first two overloads)
+or `comp` (for the last two overloads), and
+`get_allocator() == x.get_allocator()` is `true`.
+*Effects:* If `addressof(x) == this`, does nothing; otherwise, merges
+the two sorted ranges `[begin(), end())` and `[x.begin(), x.end())`. The
+result is a range in which the elements will be sorted in non-decreasing
+order according to the ordering defined by `comp`; that is, for every
+iterator `i`, in the range other than the first, the condition
 `comp(*i, *(i - 1))` will be `false`. Pointers and references to the
 moved elements of `x` now refer to those same elements but as members of
 `*this`. Iterators referring to the moved elements will continue to
 refer to their elements, but they now behave as iterators into `*this`,
 not into `x`.
+*Remarks:* Stable [[algorithm.stable]]. If `addressof(x) != this`, the
+range `[x.begin(), x.end())` is empty after the merge. No elements are
+copied by this operation.
 *Complexity:* At most `size() + x.size() - 1` applications of `comp` if
+`addressof(x) != this`; otherwise, no applications of `comp` are
+performed. If an exception is thrown other than by a comparison there
+are no effects.
 ``` cpp
 void reverse() noexcept;
 ```
 ``` cpp
 void sort();
 template<class Compare> void sort(Compare comp);
 ```
 *Effects:* Sorts the list according to the `operator<` or a `Compare`
 function object. If an exception is thrown, the order of the elements in
 `*this` is unspecified. Does not affect the validity of iterators and
 references.
+*Remarks:* Stable [[algorithm.stable]].
 *Complexity:* Approximately N log N comparisons, where `N == size()`.
+#### Erasure <a id="list.erasure">[[list.erasure]]</a>
 ``` cpp
+template<class T, class Allocator, class U>
+ typename list<T, Allocator>::size_type
+ erase(list<T, Allocator>& c, const U& value);
 ```
+*Effects:* Equivalent to:
+`return erase_if(c, [&](auto& elem) { return elem == value; });`
+``` cpp
+template<class T, class Allocator, class Predicate>
+  typename list<T, Allocator>::size_type
+    erase_if(list<T, Allocator>& c, Predicate pred);
+```
+*Effects:* Equivalent to: `return c.remove_if(pred);`

Diff to HTML by rtfpessoa