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

Files changed (1) hide show

tmp/tmp8xu3u37x/{from.md → to.md} +90 -94

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

@@ -1,29 +1,28 @@
 ### Class template `forward_list` <a id="forwardlist">[[forwardlist]]</a>
-#### Class template `forward_list` overview <a id="forwardlist.overview">[[forwardlist.overview]]</a>
 A `forward_list` is a container that supports forward iterators and
 allows constant time insert and erase operations anywhere within the
 sequence, with storage management handled automatically. Fast random
 access to list elements is not supported.
 [*Note 1*: It is intended that `forward_list` have zero space or time
 overhead relative to a hand-written C-style singly linked list. Features
 that would conflict with that goal have been omitted. — *end note*]
-A `forward_list` satisfies all of the requirements of a container
-(Table  [[tab:containers.container.requirements]]), except that the
-`size()` member function is not provided and `operator==` has linear
-complexity. A `forward_list` also satisfies all of the requirements for
-an allocator-aware container (Table  [[tab:containers.allocatoraware]]).
-In addition, a `forward_list` provides the `assign` member functions
-(Table  [[tab:containers.sequence.requirements]]) and several of the
-optional container requirements (Table
-[[tab:containers.sequence.optional]]). Descriptions are provided here
-only for operations on `forward_list` that are not described in that
-table or for operations where there is additional semantic information.
 [*Note 2*: Modifying any list requires access to the element preceding
 the first element of interest, but in a `forward_list` there is no
 constant-time way to access a preceding element. For this reason, ranges
 that are modified, such as those supplied to `erase` and `splice`, must
@@ -32,11 +31,11 @@ be open at the beginning. — *end note*]
 ``` cpp
 namespace std {
   template<class T, class Allocator = allocator<T>>
   class forward_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&;
@@ -48,15 +47,13 @@ namespace std {
     // [forwardlist.cons], construct/copy/destroy
     forward_list() : forward_list(Allocator()) { }
     explicit forward_list(const Allocator&);
     explicit forward_list(size_type n, const Allocator& = Allocator());
-    forward_list(size_type n, const T& value,
-                 const Allocator& = Allocator());
     template<class InputIterator>
-      forward_list(InputIterator first, InputIterator last,
-                   const Allocator& = Allocator());
     forward_list(const forward_list& x);
     forward_list(forward_list&& x);
     forward_list(const forward_list& x, const Allocator&);
     forward_list(forward_list&& x, const Allocator&);
     forward_list(initializer_list<T>, const Allocator& = Allocator());
@@ -81,12 +78,12 @@ namespace std {
     const_iterator cbegin() const noexcept;
     const_iterator cbefore_begin() const noexcept;
     const_iterator cend() const noexcept;
-    // capacity:
-    bool empty() const noexcept;
     size_type max_size() const noexcept;
     // [forwardlist.access], element access
     reference front();
     const_reference front() const;
@@ -116,24 +113,22 @@ namespace std {
     void clear() noexcept;
     // [forwardlist.ops], forward_list operations
     void splice_after(const_iterator position, forward_list& x);
     void splice_after(const_iterator position, forward_list&& x);
-    void splice_after(const_iterator position, forward_list& x,
- const_iterator i);
-    void splice_after(const_iterator position, forward_list&& x,
-                      const_iterator i);
     void splice_after(const_iterator position, forward_list& x,
                       const_iterator first, const_iterator last);
     void splice_after(const_iterator position, forward_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(forward_list& x);
     void merge(forward_list&& x);
     template<class Compare> void merge(forward_list& x, Compare comp);
     template<class Compare> void merge(forward_list&& x, Compare comp);
@@ -142,42 +137,28 @@ namespace std {
     template<class Compare> void sort(Compare comp);
     void reverse() noexcept;
   };
-  template<class InputIterator,
-           class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
     forward_list(InputIterator, InputIterator, Allocator = Allocator())
-      -> forward_list<typename iterator_traits<InputIterator>::value_type, Allocator>;
- template <class T, class Allocator>
-    bool operator==(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
-  template <class T, class Allocator>
-    bool operator< (const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
-  template <class T, class Allocator>
-    bool operator!=(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
-  template <class T, class Allocator>
-    bool operator> (const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
-  template <class T, class Allocator>
-    bool operator>=(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
-  template <class T, class Allocator>
-    bool operator<=(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
-  // [forwardlist.spec], specialized algorithms
   template<class T, class Allocator>
     void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
 }
 ```
 An incomplete type `T` may be used when instantiating `forward_list` if
-the allocator satisfies the allocator completeness requirements (
-[[allocator.requirements.completeness]]). `T` shall be complete before
 any member of the resulting specialization of `forward_list` is
 referenced.
-#### `forward_list` constructors, copy, assignment <a id="forwardlist.cons">[[forwardlist.cons]]</a>
 ``` cpp
 explicit forward_list(const Allocator&);
 ```
@@ -188,26 +169,26 @@ allocator.
 ``` cpp
 explicit forward_list(size_type n, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `forward_list` object with `n` default-inserted
 elements using the specified allocator.
-*Requires:* `T` shall be `DefaultInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
 forward_list(size_type n, const T& value, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `forward_list` object with `n` copies of `value`
 using the specified allocator.
-*Requires:* `T` shall be `CopyInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
 template<class InputIterator>
   forward_list(InputIterator first, InputIterator last, const Allocator& = Allocator());
@@ -216,11 +197,11 @@ template <class InputIterator>
 *Effects:* Constructs a `forward_list` object equal to the range
 \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
-#### `forward_list` iterators <a id="forwardlist.iter">[[forwardlist.iter]]</a>
 ``` cpp
 iterator before_begin() noexcept;
 const_iterator before_begin() const noexcept;
 const_iterator cbefore_begin() const noexcept;
@@ -232,20 +213,20 @@ equal to the iterator returned by `begin()`.
 *Effects:* `cbefore_begin()` is equivalent to
 `const_cast<forward_list const&>(*this).before_begin()`.
 *Remarks:* `before_begin() == end()` shall equal `false`.
-#### `forward_list` element access <a id="forwardlist.access">[[forwardlist.access]]</a>
 ``` cpp
 reference front();
 const_reference front() const;
 ```
 *Returns:* `*begin()`
-#### `forward_list` modifiers <a id="forwardlist.modifiers">[[forwardlist.modifiers]]</a>
 None of the overloads of `insert_after` shall affect the validity of
 iterators and references, and `erase_after` shall invalidate only
 iterators and references to the erased elements. If an exception is
 thrown during `insert_after` there shall be no effect. Inserting `n`
@@ -277,22 +258,22 @@ void pop_front();
 ``` cpp
 iterator insert_after(const_iterator position, const T& x);
 iterator insert_after(const_iterator position, T&& x);
 ```
-*Requires:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`).
 *Effects:* Inserts a copy of `x` after `position`.
 *Returns:* An iterator pointing to the copy of `x`.
 ``` cpp
 iterator insert_after(const_iterator position, size_type n, const T& x);
 ```
-*Requires:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`).
 *Effects:* Inserts `n` copies of `x` after `position`.
 *Returns:* An iterator pointing to the last inserted copy of `x` or
@@ -301,13 +282,13 @@ iterator in the range \[`begin()`, `end()`).
 ``` cpp
 template<class InputIterator>
   iterator insert_after(const_iterator position, InputIterator first, InputIterator last);
 ```
-*Requires:* `position` is `before_begin()` or is a dereferenceable
-iterator in the range \[`begin()`, `end()`). `first` and `last` are not
-iterators in `*this`.
 *Effects:* Inserts copies of elements in \[`first`, `last`) after
 `position`.
 *Returns:* An iterator pointing to the last inserted element or
@@ -325,11 +306,11 @@ iterator insert_after(const_iterator position, initializer_list<T> il);
 ``` cpp
 template<class... Args>
   iterator emplace_after(const_iterator position, Args&&... args);
 ```
-*Requires:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`).
 *Effects:* Inserts an object of type `value_type` constructed with
 `value_type(std::forward<Args>(args)...)` after `position`.
@@ -337,11 +318,11 @@ iterator in the range \[`begin()`, `end()`).
 ``` cpp
 iterator erase_after(const_iterator position);
 ```
-*Requires:* The iterator following `position` is dereferenceable.
 *Effects:* Erases the element pointed to by the iterator following
 `position`.
 *Returns:* An iterator pointing to the element following the one that
@@ -351,11 +332,11 @@ was erased, or `end()` if no such element exists.
 ``` cpp
 iterator erase_after(const_iterator position, const_iterator last);
 ```
-*Requires:* All iterators in the range (`position`, `last`) are
 dereferenceable.
 *Effects:* Erases the elements in the range (`position`, `last`).
 *Returns:* `last`.
@@ -364,46 +345,52 @@ dereferenceable.
 ``` cpp
 void resize(size_type sz);
 ```
 *Effects:* If `sz < distance(begin(), end())`, erases the last
 `distance(begin(), end()) - sz` elements from the list. Otherwise,
 inserts `sz - distance(begin(), end())` default-inserted elements at the
 end of the list.
-*Requires:* `T` shall be `DefaultInsertable` into `*this`.
 ``` cpp
 void resize(size_type sz, const value_type& c);
 ```
 *Effects:* If `sz < distance(begin(), end())`, erases the last
 `distance(begin(), end()) - sz` elements from the list. Otherwise,
 inserts `sz - distance(begin(), end())` copies of `c` at the end of the
 list.
-*Requires:* `T` shall be `CopyInsertable` into `*this`.
 ``` cpp
 void clear() noexcept;
 ```
 *Effects:* Erases all elements in the range \[`begin()`, `end()`).
 *Remarks:* Does not invalidate past-the-end iterators.
-#### `forward_list` operations <a id="forwardlist.ops">[[forwardlist.ops]]</a>
 ``` cpp
 void splice_after(const_iterator position, forward_list& x);
 void splice_after(const_iterator position, forward_list&& x);
 ```
-*Requires:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`).
-`get_allocator() == x.get_allocator()`. `&x != this`.
 *Effects:* Inserts the contents of `x` after `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
@@ -416,14 +403,14 @@ now behave as iterators into `*this`, not into `x`.
 ``` cpp
 void splice_after(const_iterator position, forward_list& x, const_iterator i);
 void splice_after(const_iterator position, forward_list&& x, const_iterator i);
 ```
-*Requires:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). The iterator following `i`
 is a dereferenceable iterator in `x`.
-`get_allocator() == x.get_allocator()`.
 *Effects:* Inserts the element following `i` into `*this`, following
 `position`, and removes it from `x`. The result is unchanged if
 `position == i` or `position == ++i`. Pointers and references to `*++i`
 continue to refer to the same element but as a member of `*this`.
@@ -439,15 +426,15 @@ void splice_after(const_iterator position, forward_list& x,
                   const_iterator first, const_iterator last);
 void splice_after(const_iterator position, forward_list&& x,
                   const_iterator first, const_iterator last);
 ```
-*Requires:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). (`first`, `last`) is a
 valid range in `x`, and all iterators in the range (`first`, `last`) are
 dereferenceable. `position` is not an iterator in the range (`first`,
-`last`). `get_allocator() == x.get_allocator()`.
 *Effects:* Inserts elements in the range (`first`, `last`) after
 `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
@@ -455,39 +442,43 @@ continue to refer to their elements, but they now behave as iterators
 into `*this`, not into `x`.
 *Complexity:* 𝑂(`distance(first, last)`)
 ``` 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` (for
 `remove()`), `pred(*i)` is `true` (for `remove_if()`). Invalidates only
 the iterators and references to the erased elements.
 *Throws:* Nothing unless an exception is thrown by the equality
 comparison or the predicate.
-*Remarks:* Stable ([[algorithm.stable]]).
 *Complexity:* Exactly `distance(begin(), end())` applications of the
 corresponding predicate.
 ``` cpp
-void unique();
-template <class BinaryPredicate> void unique(BinaryPredicate 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 with no
 arguments) or `pred(*i, *(i - 1))` (for the version with a predicate
 argument) holds. Invalidates only the iterators and references to the
 erased elements.
 *Throws:* Nothing unless an exception is thrown by the equality
 comparison or the predicate.
 *Complexity:* If the range \[`first`, `last`) is not empty, exactly
 `(last - first) - 1` applications of the corresponding predicate,
@@ -498,44 +489,40 @@ void merge(forward_list& x);
 void merge(forward_list&& x);
 template<class Compare> void merge(forward_list& x, Compare comp);
 template<class Compare> void merge(forward_list&& x, Compare comp);
 ```
-*Requires:* `comp` defines a strict weak ordering ([[alg.sorting]]),
-and `*this` and `x` are both sorted according to this ordering.
-`get_allocator() == x.get_allocator()`.
 *Effects:* Merges the two sorted ranges `[begin(), end())` and
 `[x.begin(), x.end())`. `x` is empty after the merge. If an exception is
 thrown other than by a comparison there are no effects. 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]]). The behavior is undefined if
-`get_allocator() != x.get_allocator()`.
 *Complexity:* At most
 `distance(begin(), end()) + distance(x.begin(), x.end()) - 1`
 comparisons.
 ``` cpp
 void sort();
 template<class Compare> void sort(Compare comp);
 ```
-*Requires:* `operator<` (for the version with no arguments) or `comp`
-(for the version with a comparison argument) defines a strict weak
-ordering ([[alg.sorting]]).
 *Effects:* Sorts the list according to the `operator<` or the `comp`
 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 is
 `distance(begin(), end())`.
 ``` cpp
@@ -545,15 +532,24 @@ void reverse() noexcept;
 *Effects:* Reverses the order of the elements in the list. Does not
 affect the validity of iterators and references.
 *Complexity:* Linear time.
-#### `forward_list` specialized algorithms <a id="forwardlist.spec">[[forwardlist.spec]]</a>
 ``` cpp
-template <class T, class Allocator>
- void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
- noexcept(noexcept(x.swap(y)));
 ```
-*Effects:* As if by `x.swap(y)`.

 ### Class template `forward_list` <a id="forwardlist">[[forwardlist]]</a>
+#### Overview <a id="forwardlist.overview">[[forwardlist.overview]]</a>
 A `forward_list` is a container that supports forward iterators and
 allows constant time insert and erase operations anywhere within the
 sequence, with storage management handled automatically. Fast random
 access to list elements is not supported.
 [*Note 1*: It is intended that `forward_list` have zero space or time
 overhead relative to a hand-written C-style singly linked list. Features
 that would conflict with that goal have been omitted. — *end note*]
+A `forward_list` meets all of the requirements of a container (
+[[container.req]]), except that the `size()` member function is not
+provided and `operator==` has linear complexity. A `forward_list` also
+meets all of the requirements for an allocator-aware container (
+[[container.alloc.req]]). In addition, a `forward_list` provides the
+`assign` member functions ([[container.seq.req]]) and several of the
+optional container requirements ([[container.seq.opt]]). Descriptions
+are provided here only for operations on `forward_list` that are not
+described in that table or for operations where there is additional
+semantic information.
 [*Note 2*: Modifying any list requires access to the element preceding
 the first element of interest, but in a `forward_list` there is no
 constant-time way to access a preceding element. For this reason, ranges
 that are modified, such as those supplied to `erase` and `splice`, must
 ``` cpp
 namespace std {
   template<class T, class Allocator = allocator<T>>
   class forward_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&;
     // [forwardlist.cons], construct/copy/destroy
     forward_list() : forward_list(Allocator()) { }
     explicit forward_list(const Allocator&);
     explicit forward_list(size_type n, const Allocator& = Allocator());
+    forward_list(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
+      forward_list(InputIterator first, InputIterator last, const Allocator& = Allocator());
     forward_list(const forward_list& x);
     forward_list(forward_list&& x);
     forward_list(const forward_list& x, const Allocator&);
     forward_list(forward_list&& x, const Allocator&);
     forward_list(initializer_list<T>, const Allocator& = Allocator());
     const_iterator cbegin() const noexcept;
     const_iterator cbefore_begin() const noexcept;
     const_iterator cend() const noexcept;
+    // capacity
+ [[nodiscard]] bool empty() const noexcept;
     size_type max_size() const noexcept;
     // [forwardlist.access], element access
     reference front();
     const_reference front() const;
     void clear() noexcept;
     // [forwardlist.ops], forward_list operations
     void splice_after(const_iterator position, forward_list& x);
     void splice_after(const_iterator position, forward_list&& x);
+    void splice_after(const_iterator position, forward_list& x, const_iterator i);
+    void splice_after(const_iterator position, forward_list&& x, const_iterator i);
     void splice_after(const_iterator position, forward_list& x,
                       const_iterator first, const_iterator last);
     void splice_after(const_iterator position, forward_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(forward_list& x);
     void merge(forward_list&& x);
     template<class Compare> void merge(forward_list& x, Compare comp);
     template<class Compare> void merge(forward_list&& x, Compare comp);
     template<class Compare> void sort(Compare comp);
     void reverse() noexcept;
   };
+  template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     forward_list(InputIterator, InputIterator, Allocator = Allocator())
+      -> forward_list<iter-value-type<InputIterator>, Allocator>;
+ // swap
   template<class T, class Allocator>
     void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
 }
 ```
 An incomplete type `T` may be used when instantiating `forward_list` if
+the allocator meets the allocator completeness requirements
+[[allocator.requirements.completeness]]. `T` shall be complete before
 any member of the resulting specialization of `forward_list` is
 referenced.
+#### Constructors, copy, and assignment <a id="forwardlist.cons">[[forwardlist.cons]]</a>
 ``` cpp
 explicit forward_list(const Allocator&);
 ```
 ``` cpp
 explicit forward_list(size_type n, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `*this`.
 *Effects:* Constructs a `forward_list` object with `n` default-inserted
 elements using the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 forward_list(size_type n, const T& value, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* Constructs a `forward_list` object with `n` copies of `value`
 using the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 template<class InputIterator>
   forward_list(InputIterator first, InputIterator last, const Allocator& = Allocator());
 *Effects:* Constructs a `forward_list` object equal to the range
 \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
+#### Iterators <a id="forwardlist.iter">[[forwardlist.iter]]</a>
 ``` cpp
 iterator before_begin() noexcept;
 const_iterator before_begin() const noexcept;
 const_iterator cbefore_begin() const noexcept;
 *Effects:* `cbefore_begin()` is equivalent to
 `const_cast<forward_list const&>(*this).before_begin()`.
 *Remarks:* `before_begin() == end()` shall equal `false`.
+#### Element access <a id="forwardlist.access">[[forwardlist.access]]</a>
 ``` cpp
 reference front();
 const_reference front() const;
 ```
 *Returns:* `*begin()`
+#### Modifiers <a id="forwardlist.modifiers">[[forwardlist.modifiers]]</a>
 None of the overloads of `insert_after` shall affect the validity of
 iterators and references, and `erase_after` shall invalidate only
 iterators and references to the erased elements. If an exception is
 thrown during `insert_after` there shall be no effect. Inserting `n`
 ``` cpp
 iterator insert_after(const_iterator position, const T& x);
 iterator insert_after(const_iterator position, T&& x);
 ```
+*Preconditions:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`).
 *Effects:* Inserts a copy of `x` after `position`.
 *Returns:* An iterator pointing to the copy of `x`.
 ``` cpp
 iterator insert_after(const_iterator position, size_type n, const T& x);
 ```
+*Preconditions:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`).
 *Effects:* Inserts `n` copies of `x` after `position`.
 *Returns:* An iterator pointing to the last inserted copy of `x` or
 ``` cpp
 template<class InputIterator>
   iterator insert_after(const_iterator position, InputIterator first, InputIterator last);
 ```
+*Preconditions:* `position` is `before_begin()` or is a dereferenceable
+iterator in the range \[`begin()`, `end()`). Neither `first` nor `last`
+are iterators in `*this`.
 *Effects:* Inserts copies of elements in \[`first`, `last`) after
 `position`.
 *Returns:* An iterator pointing to the last inserted element or
 ``` cpp
 template<class... Args>
   iterator emplace_after(const_iterator position, Args&&... args);
 ```
+*Preconditions:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`).
 *Effects:* Inserts an object of type `value_type` constructed with
 `value_type(std::forward<Args>(args)...)` after `position`.
 ``` cpp
 iterator erase_after(const_iterator position);
 ```
+*Preconditions:* The iterator following `position` is dereferenceable.
 *Effects:* Erases the element pointed to by the iterator following
 `position`.
 *Returns:* An iterator pointing to the element following the one that
 ``` cpp
 iterator erase_after(const_iterator position, const_iterator last);
 ```
+*Preconditions:* All iterators in the range (`position`, `last`) are
 dereferenceable.
 *Effects:* Erases the elements in the range (`position`, `last`).
 *Returns:* `last`.
 ``` cpp
 void resize(size_type sz);
 ```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `*this`.
 *Effects:* If `sz < distance(begin(), end())`, erases the last
 `distance(begin(), end()) - sz` elements from the list. Otherwise,
 inserts `sz - distance(begin(), end())` default-inserted elements at the
 end of the list.
 ``` cpp
 void resize(size_type sz, const value_type& c);
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* If `sz < distance(begin(), end())`, erases the last
 `distance(begin(), end()) - sz` elements from the list. Otherwise,
 inserts `sz - distance(begin(), end())` copies of `c` at the end of the
 list.
 ``` cpp
 void clear() noexcept;
 ```
 *Effects:* Erases all elements in the range \[`begin()`, `end()`).
 *Remarks:* Does not invalidate past-the-end iterators.
+#### Operations <a id="forwardlist.ops">[[forwardlist.ops]]</a>
+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.
 ``` cpp
 void splice_after(const_iterator position, forward_list& x);
 void splice_after(const_iterator position, forward_list&& x);
 ```
+*Preconditions:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`).
+`get_allocator() == x.get_allocator()` is `true`. `addressof(x) != this`
+is `true`.
 *Effects:* Inserts the contents of `x` after `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_after(const_iterator position, forward_list& x, const_iterator i);
 void splice_after(const_iterator position, forward_list&& x, const_iterator i);
 ```
+*Preconditions:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). The iterator following `i`
 is a dereferenceable iterator in `x`.
+`get_allocator() == x.get_allocator()` is `true`.
 *Effects:* Inserts the element following `i` into `*this`, following
 `position`, and removes it from `x`. The result is unchanged if
 `position == i` or `position == ++i`. Pointers and references to `*++i`
 continue to refer to the same element but as a member of `*this`.
                   const_iterator first, const_iterator last);
 void splice_after(const_iterator position, forward_list&& x,
                   const_iterator first, const_iterator last);
 ```
+*Preconditions:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). (`first`, `last`) is a
 valid range in `x`, and all iterators in the range (`first`, `last`) are
 dereferenceable. `position` is not an iterator in the range (`first`,
+`last`). `get_allocator() == x.get_allocator()` is `true`.
 *Effects:* Inserts elements in the range (`first`, `last`) after
 `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
 into `*this`, not into `x`.
 *Complexity:* 𝑂(`distance(first, last)`)
 ``` 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` (for
 `remove()`), `pred(*i)` is `true` (for `remove_if()`). Invalidates only
 the iterators and references to the erased elements.
+*Returns:* The number of elements erased.
 *Throws:* Nothing unless an exception is thrown by the equality
 comparison or the predicate.
+*Remarks:* Stable [[algorithm.stable]].
 *Complexity:* Exactly `distance(begin(), end())` applications of the
 corresponding predicate.
 ``` cpp
+size_type unique();
+template<class BinaryPredicate> size_type unique(BinaryPredicate 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 with no
 arguments) or `pred(*i, *(i - 1))` (for the version 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 the equality
 comparison or the predicate.
 *Complexity:* If the range \[`first`, `last`) is not empty, exactly
 `(last - first) - 1` applications of the corresponding predicate,
 void merge(forward_list&& x);
 template<class Compare> void merge(forward_list& x, Compare comp);
 template<class Compare> void merge(forward_list&& x, Compare comp);
 ```
+*Preconditions:* `*this` and `x` are both 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:* Merges the two sorted ranges `[begin(), end())` and
 `[x.begin(), x.end())`. `x` is empty after the merge. If an exception is
 thrown other than by a comparison there are no effects. 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]].
 *Complexity:* At most
 `distance(begin(), end()) + distance(x.begin(), x.end()) - 1`
 comparisons.
 ``` cpp
 void sort();
 template<class Compare> void sort(Compare comp);
 ```
 *Effects:* Sorts the list according to the `operator<` or the `comp`
 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 is
 `distance(begin(), end())`.
 ``` cpp
 *Effects:* Reverses the order of the elements in the list. Does not
 affect the validity of iterators and references.
 *Complexity:* Linear time.
+#### Erasure <a id="forward.list.erasure">[[forward.list.erasure]]</a>
 ``` cpp
+template<class T, class Allocator, class U>
+ typename forward_list<T, Allocator>::size_type
+ erase(forward_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 forward_list<T, Allocator>::size_type
+    erase_if(forward_list<T, Allocator>& c, Predicate pred);
+```
+*Effects:* Equivalent to: `return c.remove_if(pred);`

Diff to HTML by rtfpessoa