[forward.list] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpfhwlahsh/{from.md → to.md} +141 -130

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

@@ -11,11 +11,11 @@ access to list elements is not supported.
 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.reqmts]], 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.reqmts]]. In addition, a `forward_list` provides the
 `assign` member functions and several of the optional sequence container
 requirements [[sequence.reqmts]]. Descriptions are provided here only
 for operations on `forward_list` that are not described in that table or
@@ -25,127 +25,133 @@ for operations where there is additional semantic information.
 the first element of interest, but in a `forward_list` there is no
 constant-time way to access a preceding element. For this reason,
 `erase_after` and `splice_after` take fully-open ranges, not semi-open
 ranges. — *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&;
     using const_reference = const value_type&;
     using size_type       = implementation-defined  // type of forward_list::size_type; // see [container.requirements]
     using difference_type = implementation-defined  // type of forward_list::difference_type; // see [container.requirements]
     using iterator        = implementation-defined  // type of forward_list::iterator; // see [container.requirements]
     using const_iterator  = implementation-defined  // type of forward_list::const_iterator; // see [container.requirements]
     // [forward.list.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());
     template<container-compatible-range<T> R>
-      forward_list(from_range_t, R&& rg, const Allocator& = Allocator());
-    forward_list(const forward_list& x);
-    forward_list(forward_list&& x);
-    forward_list(const forward_list& x, const type_identity_t<Allocator>&);
-    forward_list(forward_list&& x, const type_identity_t<Allocator>&);
-    forward_list(initializer_list<T>, const Allocator& = Allocator());
-    ~forward_list();
-    forward_list& operator=(const forward_list& x);
-    forward_list& operator=(forward_list&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
-    forward_list& operator=(initializer_list<T>);
     template<class InputIterator>
-      void assign(InputIterator first, InputIterator last);
     template<container-compatible-range<T> R>
-      void assign_range(R&& rg);
-    void assign(size_type n, const T& t);
-    void assign(initializer_list<T>);
-    allocator_type get_allocator() const noexcept;
     // [forward.list.iter], iterators
-    iterator before_begin() noexcept;
-    const_iterator before_begin() const noexcept;
-    iterator begin() noexcept;
-    const_iterator begin() const noexcept;
-    iterator end() noexcept;
-    const_iterator end() const noexcept;
-    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;
     // [forward.list.access], element access
-    reference front();
-    const_reference front() const;
     // [forward.list.modifiers], modifiers
-    template<class... Args> reference emplace_front(Args&&... args);
-    void push_front(const T& x);
-    void push_front(T&& x);
     template<container-compatible-range<T> R>
-      void prepend_range(R&& rg);
-    void pop_front();
-    template<class... Args> iterator emplace_after(const_iterator position, Args&&... args);
- iterator insert_after(const_iterator position, const T& x);
-    iterator insert_after(const_iterator position, T&& x);
-    iterator insert_after(const_iterator position, size_type n, const T& x);
     template<class InputIterator>
-      iterator insert_after(const_iterator position, InputIterator first, InputIterator last);
-    iterator insert_after(const_iterator position, initializer_list<T> il);
     template<container-compatible-range<T> R>
-      iterator insert_range_after(const_iterator position, R&& rg);
-    iterator erase_after(const_iterator position);
-    iterator erase_after(const_iterator position, const_iterator last);
-    void swap(forward_list&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
-    void resize(size_type sz);
-    void resize(size_type sz, const value_type& c);
-    void clear() noexcept;
     // [forward.list.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);
-    void sort();
-    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>;
@@ -163,66 +169,66 @@ any member of the resulting specialization of `forward_list` is
 referenced.
 #### Constructors, copy, and assignment <a id="forward.list.cons">[[forward.list.cons]]</a>
 ``` cpp
-explicit forward_list(const Allocator&);
 ```
 *Effects:* Constructs an empty `forward_list` object using the specified
 allocator.
 *Complexity:* Constant.
 ``` 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)`.
 ``` cpp
 template<container-compatible-range<T> R>
-  forward_list(from_range_t, R&& rg, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `forward_list` object with the elements of the
 range `rg`.
 *Complexity:* Linear in `ranges::distance(rg)`.
 #### Iterators <a id="forward.list.iter">[[forward.list.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()`.
@@ -232,59 +238,60 @@ equal to the iterator returned by `begin()`.
 *Remarks:* `before_begin() == end()` shall equal `false`.
 #### Element access <a id="forward.list.access">[[forward.list.access]]</a>
 ``` cpp
-reference front();
-const_reference front() const;
 ```
 *Returns:* `*begin()`
 #### Modifiers <a id="forward.list.modifiers">[[forward.list.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`
-elements into a `forward_list` is linear in `n`, and the number of calls
-to the copy or move constructor of `T` is exactly equal to `n`. Erasing
-`n` elements from a `forward_list` is linear in `n` and the number of
-calls to the destructor of type `T` is exactly equal to `n`.
 ``` cpp
-template<class... Args> reference emplace_front(Args&&... args);
 ```
 *Effects:* Inserts an object of type `value_type` constructed with
 `value_type(std::forward<Args>(args)...)` at the beginning of the list.
 ``` cpp
-void push_front(const T& x);
-void push_front(T&& x);
 ```
 *Effects:* Inserts a copy of `x` at the beginning of the list.
 ``` cpp
 template<container-compatible-range<T> R>
-  void prepend_range(R&& rg);
 ```
 *Effects:* Inserts a copy of each element of `rg` at the beginning of
 the list.
 [*Note 1*: The order of elements is not reversed. — *end note*]
 ``` cpp
-void pop_front();
 ```
 *Effects:* As if by `erase_after(before_begin())`.
 ``` cpp
-iterator insert_after(const_iterator position, const T& x);
 ```
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `forward_list`.
 `position` is `before_begin()` or is a dereferenceable iterator in the
 range \[`begin()`, `end()`).
@@ -292,11 +299,11 @@ 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, T&& x);
 ```
 *Preconditions:* `T` is *Cpp17MoveInsertable* into `forward_list`.
 `position` is `before_begin()` or is a dereferenceable iterator in the
 range \[`begin()`, `end()`).
@@ -304,11 +311,11 @@ 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:* `T` is *Cpp17CopyInsertable* into `forward_list`.
 `position` is `before_begin()` or is a dereferenceable iterator in the
 range \[`begin()`, `end()`).
@@ -318,11 +325,12 @@ range \[`begin()`, `end()`).
 *Returns:* An iterator pointing to the last inserted copy of `x`, or
 `position` if `n == 0` is `true`.
 ``` cpp
 template<class InputIterator>
-  iterator insert_after(const_iterator position, InputIterator first, InputIterator last);
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `forward_list`
 from `*first`. `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). Neither `first` nor `last`
@@ -334,11 +342,11 @@ are iterators in `*this`.
 *Returns:* An iterator pointing to the last inserted element, or
 `position` if `first == last` is `true`.
 ``` cpp
 template<container-compatible-range<T> R>
-  iterator insert_range_after(const_iterator position, R&& rg);
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `forward_list`
 from `*ranges::begin(rg)`. `position` is `before_begin()` or is a
 dereferenceable iterator in the range \[`begin()`, `end()`). `rg` and
@@ -349,19 +357,19 @@ dereferenceable iterator in the range \[`begin()`, `end()`). `rg` and
 *Returns:* An iterator pointing to the last inserted element, or
 `position` if `rg` is empty.
 ``` cpp
-iterator insert_after(const_iterator position, initializer_list<T> il);
 ```
 *Effects:* Equivalent to:
 `return insert_after(position, il.begin(), il.end());`
 ``` cpp
 template<class... Args>
-  iterator emplace_after(const_iterator position, Args&&... args);
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `forward_list`
 from `std::forward<Args>(args)...`. `position` is `before_begin()` or is
 a dereferenceable iterator in the range \[`begin()`, `end()`).
@@ -371,11 +379,11 @@ direct-non-list-initialized with `std::forward<Args>(args)...` after
 `position`.
 *Returns:* An iterator pointing to the new object.
 ``` cpp
-iterator erase_after(const_iterator position);
 ```
 *Preconditions:* The iterator following `position` is dereferenceable.
 *Effects:* Erases the element pointed to by the iterator following
@@ -385,11 +393,11 @@ iterator erase_after(const_iterator position);
 was erased, or `end()` if no such element exists.
 *Throws:* Nothing.
 ``` cpp
-iterator erase_after(const_iterator position, const_iterator last);
 ```
 *Preconditions:* All iterators in the range (`position`, `last`) are
 dereferenceable.
@@ -398,33 +406,33 @@ dereferenceable.
 *Returns:* `last`.
 *Throws:* Nothing.
 ``` 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.
@@ -439,12 +447,12 @@ iterator into the list and `n` is an integer, are the same as those of
 list and `n` is an integer, means an iterator `j` such that `j + n == i`
 is `true`. 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`
@@ -459,12 +467,12 @@ now behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* 𝑂(`distance(x.begin(), x.end())`)
 ``` 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`.
@@ -480,13 +488,13 @@ behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* 𝑂(1)
 ``` cpp
-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);
 ```
 *Preconditions:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). (`first`, `last`) is a
@@ -502,12 +510,12 @@ continue to refer to their elements, but they now behave as iterators
 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
@@ -522,12 +530,12 @@ comparison or the predicate.
 corresponding predicate.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
-size_type unique();
-template<class BinaryPredicate> size_type unique(BinaryPredicate binary_pred);
 ```
 Let `binary_pred` be `equal_to<>{}` for the first overload.
 *Preconditions:* `binary_pred` is an equivalence relation.
@@ -545,14 +553,14 @@ only the iterators and references to the erased elements.
 *Complexity:* If `empty()` is `false`, exactly
 `distance(begin(), end()) - 1` applications of the corresponding
 predicate, otherwise no applications of the predicate.
 ``` cpp
-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);
 ```
 Let `comp` be `less<>` for the first two overloads.
 *Preconditions:* `*this` and `x` are both sorted with respect to the
@@ -574,12 +582,12 @@ performed.
 *Remarks:* Stable [[algorithm.stable]]. If `addressof(x) != this`, `x`
 is empty after the merge. No elements are copied by this operation. If
 an exception is thrown other than by a comparison, there are no effects.
 ``` 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
@@ -589,32 +597,35 @@ references.
 `distance(begin(), end())`.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
-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.
 #### 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);`

 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.reqmts]], 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.reqmts]]. In addition, a `forward_list` provides the
 `assign` member functions and several of the optional sequence container
 requirements [[sequence.reqmts]]. Descriptions are provided here only
 for operations on `forward_list` that are not described in that table or
 the first element of interest, but in a `forward_list` there is no
 constant-time way to access a preceding element. For this reason,
 `erase_after` and `splice_after` take fully-open ranges, not semi-open
 ranges. — *end note*]
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 ``` 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         = allocator_traits<Allocator>::pointer;
+    using const_pointer   = allocator_traits<Allocator>::const_pointer;
     using reference       = value_type&;
     using const_reference = const value_type&;
     using size_type       = implementation-defined  // type of forward_list::size_type; // see [container.requirements]
     using difference_type = implementation-defined  // type of forward_list::difference_type; // see [container.requirements]
     using iterator        = implementation-defined  // type of forward_list::iterator; // see [container.requirements]
     using const_iterator  = implementation-defined  // type of forward_list::const_iterator; // see [container.requirements]
     // [forward.list.cons], construct/copy/destroy
+ constexpr forward_list() : forward_list(Allocator()) { }
+ constexpr explicit forward_list(const Allocator&);
+ constexpr explicit forward_list(size_type n, const Allocator& = Allocator());
+ constexpr forward_list(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
+ constexpr forward_list(InputIterator first, InputIterator last,
+                             const Allocator& = Allocator());
     template<container-compatible-range<T> R>
+ constexpr forward_list(from_range_t, R&& rg, const Allocator& = Allocator());
+ constexpr forward_list(const forward_list& x);
+ constexpr forward_list(forward_list&& x);
+ constexpr forward_list(const forward_list& x, const type_identity_t<Allocator>&);
+ constexpr forward_list(forward_list&& x, const type_identity_t<Allocator>&);
+ constexpr forward_list(initializer_list<T>, const Allocator& = Allocator());
+ constexpr ~forward_list();
+ constexpr forward_list& operator=(const forward_list& x);
+ constexpr forward_list& operator=(forward_list&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
+ constexpr forward_list& operator=(initializer_list<T>);
     template<class InputIterator>
+ constexpr void assign(InputIterator first, InputIterator last);
     template<container-compatible-range<T> R>
+ constexpr void assign_range(R&& rg);
+ constexpr void assign(size_type n, const T& t);
+ constexpr void assign(initializer_list<T>);
+ constexpr allocator_type get_allocator() const noexcept;
     // [forward.list.iter], iterators
+ constexpr iterator before_begin() noexcept;
+ constexpr const_iterator before_begin() const noexcept;
+ constexpr iterator begin() noexcept;
+ constexpr const_iterator begin() const noexcept;
+ constexpr iterator end() noexcept;
+ constexpr const_iterator end() const noexcept;
+ constexpr const_iterator cbegin() const noexcept;
+ constexpr const_iterator cbefore_begin() const noexcept;
+ constexpr const_iterator cend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // [forward.list.access], element access
+ constexpr reference front();
+ constexpr const_reference front() const;
     // [forward.list.modifiers], modifiers
+    template<class... Args> constexpr reference emplace_front(Args&&... args);
+ constexpr void push_front(const T& x);
+ constexpr void push_front(T&& x);
     template<container-compatible-range<T> R>
+ constexpr void prepend_range(R&& rg);
+ constexpr void pop_front();
+    template<class... Args>
+      constexpr iterator emplace_after(const_iterator position, Args&&... args);
+ constexpr iterator insert_after(const_iterator position, const T& x);
+    constexpr iterator insert_after(const_iterator position, T&& x);
+ constexpr iterator insert_after(const_iterator position, size_type n, const T& x);
     template<class InputIterator>
+ constexpr iterator insert_after(const_iterator position,
+                                      InputIterator first, InputIterator last);
+    constexpr iterator insert_after(const_iterator position, initializer_list<T> il);
     template<container-compatible-range<T> R>
+ constexpr iterator insert_range_after(const_iterator position, R&& rg);
+ constexpr iterator erase_after(const_iterator position);
+ constexpr iterator erase_after(const_iterator position, const_iterator last);
+ constexpr void swap(forward_list&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
+ constexpr void resize(size_type sz);
+ constexpr void resize(size_type sz, const value_type& c);
+ constexpr void clear() noexcept;
     // [forward.list.ops], forward_list operations
+ constexpr void splice_after(const_iterator position, forward_list& x);
+ constexpr void splice_after(const_iterator position, forward_list&& x);
+ constexpr void splice_after(const_iterator position, forward_list& x, const_iterator i);
+ constexpr void splice_after(const_iterator position, forward_list&& x, const_iterator i);
+ constexpr void splice_after(const_iterator position, forward_list& x,
                                 const_iterator first, const_iterator last);
+ constexpr void splice_after(const_iterator position, forward_list&& x,
                                 const_iterator first, const_iterator last);
+ constexpr size_type remove(const T& value);
+    template<class Predicate> constexpr size_type remove_if(Predicate pred);
     size_type unique();
+    template<class BinaryPredicate> constexpr size_type unique(BinaryPredicate binary_pred);
+ constexpr void merge(forward_list& x);
+ constexpr void merge(forward_list&& x);
+    template<class Compare> constexpr void merge(forward_list& x, Compare comp);
+    template<class Compare> constexpr void merge(forward_list&& x, Compare comp);
+ constexpr void sort();
+    template<class Compare> constexpr void sort(Compare comp);
+ constexpr 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>;
 referenced.
 #### Constructors, copy, and assignment <a id="forward.list.cons">[[forward.list.cons]]</a>
 ``` cpp
+constexpr explicit forward_list(const Allocator&);
 ```
 *Effects:* Constructs an empty `forward_list` object using the specified
 allocator.
 *Complexity:* Constant.
 ``` cpp
+constexpr explicit forward_list(size_type n, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `forward_list`.
 *Effects:* Constructs a `forward_list` object with `n` default-inserted
 elements using the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
+constexpr forward_list(size_type n, const T& value, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `forward_list`.
 *Effects:* Constructs a `forward_list` object with `n` copies of `value`
 using the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 template<class InputIterator>
+ constexpr 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)`.
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr forward_list(from_range_t, R&& rg, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `forward_list` object with the elements of the
 range `rg`.
 *Complexity:* Linear in `ranges::distance(rg)`.
 #### Iterators <a id="forward.list.iter">[[forward.list.iter]]</a>
 ``` cpp
+constexpr iterator before_begin() noexcept;
+constexpr const_iterator before_begin() const noexcept;
+constexpr 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="forward.list.access">[[forward.list.access]]</a>
 ``` cpp
+constexpr reference front();
+constexpr const_reference front() const;
 ```
 *Returns:* `*begin()`
 #### Modifiers <a id="forward.list.modifiers">[[forward.list.modifiers]]</a>
+The member functions in this subclause do not affect the validity of
+iterators and references when inserting elements, and when erasing
+elements invalidate iterators and references to the erased elements
+only. If an exception is thrown by any of these member functions there
+is no effect on the container. Inserting `n` elements into a
+`forward_list` is linear in `n`, and the number of calls to the copy or
+move constructor of `T` is exactly equal to `n`. Erasing `n` elements
+from a `forward_list` is linear in `n` and the number of calls to the
+destructor of type `T` is exactly equal to `n`.
 ``` cpp
+template<class... Args> constexpr reference emplace_front(Args&&... args);
 ```
 *Effects:* Inserts an object of type `value_type` constructed with
 `value_type(std::forward<Args>(args)...)` at the beginning of the list.
 ``` cpp
+constexpr void push_front(const T& x);
+constexpr void push_front(T&& x);
 ```
 *Effects:* Inserts a copy of `x` at the beginning of the list.
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr void prepend_range(R&& rg);
 ```
 *Effects:* Inserts a copy of each element of `rg` at the beginning of
 the list.
 [*Note 1*: The order of elements is not reversed. — *end note*]
 ``` cpp
+constexpr void pop_front();
 ```
 *Effects:* As if by `erase_after(before_begin())`.
 ``` cpp
+constexpr iterator insert_after(const_iterator position, const T& x);
 ```
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `forward_list`.
 `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
+constexpr iterator insert_after(const_iterator position, T&& x);
 ```
 *Preconditions:* `T` is *Cpp17MoveInsertable* into `forward_list`.
 `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
+constexpr iterator insert_after(const_iterator position, size_type n, const T& x);
 ```
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `forward_list`.
 `position` is `before_begin()` or is a dereferenceable iterator in the
 range \[`begin()`, `end()`).
 *Returns:* An iterator pointing to the last inserted copy of `x`, or
 `position` if `n == 0` is `true`.
 ``` cpp
 template<class InputIterator>
+ constexpr iterator insert_after(const_iterator position,
+                                  InputIterator first, InputIterator last);
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `forward_list`
 from `*first`. `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). Neither `first` nor `last`
 *Returns:* An iterator pointing to the last inserted element, or
 `position` if `first == last` is `true`.
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr iterator insert_range_after(const_iterator position, R&& rg);
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `forward_list`
 from `*ranges::begin(rg)`. `position` is `before_begin()` or is a
 dereferenceable iterator in the range \[`begin()`, `end()`). `rg` and
 *Returns:* An iterator pointing to the last inserted element, or
 `position` if `rg` is empty.
 ``` cpp
+constexpr iterator insert_after(const_iterator position, initializer_list<T> il);
 ```
 *Effects:* Equivalent to:
 `return insert_after(position, il.begin(), il.end());`
 ``` cpp
 template<class... Args>
+ constexpr iterator emplace_after(const_iterator position, Args&&... args);
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `forward_list`
 from `std::forward<Args>(args)...`. `position` is `before_begin()` or is
 a dereferenceable iterator in the range \[`begin()`, `end()`).
 `position`.
 *Returns:* An iterator pointing to the new object.
 ``` cpp
+constexpr iterator erase_after(const_iterator position);
 ```
 *Preconditions:* The iterator following `position` is dereferenceable.
 *Effects:* Erases the element pointed to by the iterator following
 was erased, or `end()` if no such element exists.
 *Throws:* Nothing.
 ``` cpp
+constexpr iterator erase_after(const_iterator position, const_iterator last);
 ```
 *Preconditions:* All iterators in the range (`position`, `last`) are
 dereferenceable.
 *Returns:* `last`.
 *Throws:* Nothing.
 ``` cpp
+constexpr void resize(size_type sz);
 ```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `forward_list`.
 *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
+constexpr void resize(size_type sz, const value_type& c);
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `forward_list`.
 *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
+constexpr void clear() noexcept;
 ```
 *Effects:* Erases all elements in the range \[`begin()`, `end()`).
 *Remarks:* Does not invalidate past-the-end iterators.
 list and `n` is an integer, means an iterator `j` such that `j + n == i`
 is `true`. For `merge` and `sort`, the definitions and requirements in
 [[alg.sorting]] apply.
 ``` cpp
+constexpr void splice_after(const_iterator position, forward_list& x);
+constexpr 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`
 *Throws:* Nothing.
 *Complexity:* 𝑂(`distance(x.begin(), x.end())`)
 ``` cpp
+constexpr void splice_after(const_iterator position, forward_list& x, const_iterator i);
+constexpr 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`.
 *Throws:* Nothing.
 *Complexity:* 𝑂(1)
 ``` cpp
+constexpr void splice_after(const_iterator position, forward_list& x,
                             const_iterator first, const_iterator last);
+constexpr 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
 into `*this`, not into `x`.
 *Complexity:* 𝑂(`distance(first, last)`)
 ``` cpp
+constexpr size_type remove(const T& value);
+template<class Predicate> constexpr 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
 corresponding predicate.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
+constexpr size_type unique();
+template<class BinaryPredicate> constexpr size_type unique(BinaryPredicate binary_pred);
 ```
 Let `binary_pred` be `equal_to<>{}` for the first overload.
 *Preconditions:* `binary_pred` is an equivalence relation.
 *Complexity:* If `empty()` is `false`, exactly
 `distance(begin(), end()) - 1` applications of the corresponding
 predicate, otherwise no applications of the predicate.
 ``` cpp
+constexpr void merge(forward_list& x);
+constexpr void merge(forward_list&& x);
+template<class Compare> constexpr void merge(forward_list& x, Compare comp);
+template<class Compare> constexpr void merge(forward_list&& x, Compare comp);
 ```
 Let `comp` be `less<>` for the first two overloads.
 *Preconditions:* `*this` and `x` are both sorted with respect to the
 *Remarks:* Stable [[algorithm.stable]]. If `addressof(x) != this`, `x`
 is empty after the merge. No elements are copied by this operation. If
 an exception is thrown other than by a comparison, there are no effects.
 ``` cpp
+constexpr void sort();
+template<class Compare> constexpr 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
 `distance(begin(), end())`.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
+constexpr 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.
 #### Erasure <a id="forward.list.erasure">[[forward.list.erasure]]</a>
 ``` cpp
+template<class T, class Allocator, class U = T>
+ constexpr typename forward_list<T, Allocator>::size_type
     erase(forward_list<T, Allocator>& c, const U& value);
 ```
 *Effects:* Equivalent to:
+``` cpp
+return erase_if(c, [&](const auto& elem) -> bool { return elem == value; });
+```
 ``` cpp
 template<class T, class Allocator, class Predicate>
+ constexpr 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