[sequences] - C++20 → C++23

Files changed (1) hide show

tmp/tmpuemfgmkt/{from.md → to.md} +467 -247

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

@@ -76,10 +76,11 @@ namespace std {
   template<class T, class Allocator>
     void swap(deque<T, Allocator>& x, deque<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
   template<class T, class Allocator, class U>
     typename deque<T, Allocator>::size_type
       erase(deque<T, Allocator>& c, const U& value);
   template<class T, class Allocator, class Predicate>
     typename deque<T, Allocator>::size_type
@@ -97,11 +98,11 @@ namespace std {
 ``` cpp
 #include <compare>              // see [compare.syn]
 #include <initializer_list>     // see [initializer.list.syn]
 namespace std {
-  // [forwardlist], class template forward_list
   template<class T, class Allocator = allocator<T>> class forward_list;
   template<class T, class Allocator>
     bool operator==(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
   template<class T, class Allocator>
@@ -110,10 +111,11 @@ namespace std {
   template<class T, class Allocator>
     void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
   template<class T, class Allocator, class U>
     typename forward_list<T, Allocator>::size_type
       erase(forward_list<T, Allocator>& c, const U& value);
   template<class T, class Allocator, class Predicate>
     typename forward_list<T, Allocator>::size_type
@@ -144,10 +146,11 @@ namespace std {
   template<class T, class Allocator>
     void swap(list<T, Allocator>& x, list<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
   template<class T, class Allocator, class U>
     typename list<T, Allocator>::size_type
       erase(list<T, Allocator>& c, const U& value);
   template<class T, class Allocator, class Predicate>
     typename list<T, Allocator>::size_type
@@ -178,52 +181,62 @@ namespace std {
   template<class T, class Allocator>
     constexpr void swap(vector<T, Allocator>& x, vector<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
   template<class T, class Allocator, class U>
     constexpr typename vector<T, Allocator>::size_type
       erase(vector<T, Allocator>& c, const U& value);
   template<class T, class Allocator, class Predicate>
     constexpr typename vector<T, Allocator>::size_type
       erase_if(vector<T, Allocator>& c, Predicate pred);
- // [vector.bool], class vector<bool>
- template<class Allocator> class vector<bool, Allocator>;
   // hash support
   template<class T> struct hash;
   template<class Allocator> struct hash<vector<bool, Allocator>>;
- namespace pmr {
- template<class T>
-      using vector = std::vector<T, polymorphic_allocator<T>>;
-  }
 }
 ```
 ### Class template `array` <a id="array">[[array]]</a>
 #### Overview <a id="array.overview">[[array.overview]]</a>
 The header `<array>` defines a class template for storing fixed-size
 sequences of objects. An `array` is a contiguous container
-[[container.requirements.general]]. An instance of `array<T, N>` stores
-`N` elements of type `T`, so that `size() == N` is an invariant.
 An `array` is an aggregate [[dcl.init.aggr]] that can be
 list-initialized with up to `N` elements whose types are convertible to
 `T`.
-An `array` meets all of the requirements of a container and of a
-reversible container [[container.requirements]], except that a default
-constructed `array` object is not empty and that `swap` does not have
-constant complexity. An `array` meets some of the requirements of a
-sequence container [[sequence.reqmts]]. Descriptions are provided here
-only for operations on `array` that are not described in one of these
-tables and for operations where there is additional semantic
-information.
 `array<T, N>` is a structural type [[temp.param]] if `T` is a structural
 type. Two values `a1` and `a2` of type `array<T, N>` are
 template-argument-equivalent [[temp.type]] if and only if each pair of
 corresponding elements in `a1` and `a2` are
@@ -295,17 +308,17 @@ namespace std {
 ```
 #### Constructors, copy, and assignment <a id="array.cons">[[array.cons]]</a>
 The conditions for an aggregate [[dcl.init.aggr]] shall be met. Class
-`array` relies on the implicitly-declared special member functions (
-[[class.default.ctor]], [[class.dtor]], and [[class.copy.ctor]]) to
-conform to the container requirements table in
-[[container.requirements]]. In addition to the requirements specified in
-the container requirements table, the implicit move constructor and move
-assignment operator for `array` require that `T` be
-*Cpp17MoveConstructible* or *Cpp17MoveAssignable*, respectively.
 ``` cpp
 template<class T, class... U>
   array(T, U...) -> array<T, 1 + sizeof...(U)>;
 ```
@@ -339,11 +352,11 @@ constexpr void swap(array& y) noexcept(is_nothrow_swappable_v<T>);
 ```
 *Effects:* Equivalent to `swap_ranges(begin(), end(), y.begin())`.
 [*Note 1*: Unlike the `swap` function for other containers,
-`array::swap` takes linear time, may exit via an exception, and does not
 cause iterators to become associated with the other
 container. — *end note*]
 #### Specialized algorithms <a id="array.special">[[array.special]]</a>
@@ -438,17 +451,18 @@ A `deque` is a sequence container that supports random access iterators
 insert and erase operations at the beginning or the end; insert and
 erase in the middle take linear time. That is, a deque is especially
 optimized for pushing and popping elements at the beginning and end.
 Storage management is handled automatically.
-A `deque` meets all of the requirements of a container, of a reversible
-container (given in tables in  [[container.requirements]]), of a
-sequence container, including the optional sequence container
-requirements [[sequence.reqmts]], and of an allocator-aware container (
-[[container.alloc.req]]). Descriptions are provided here only for
-operations on `deque` 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 deque {
@@ -458,12 +472,12 @@ namespace std {
     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; // see [container.requirements]
-    using difference_type        = implementation-defined; // see [container.requirements]
     using iterator               = implementation-defined  // type of deque::iterator; // see [container.requirements]
     using const_iterator         = implementation-defined  // type of deque::const_iterator; // see [container.requirements]
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
@@ -472,23 +486,27 @@ namespace std {
     explicit deque(const Allocator&);
     explicit deque(size_type n, const Allocator& = Allocator());
     deque(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
       deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
     deque(const deque& x);
     deque(deque&&);
-    deque(const deque&, const Allocator&);
-    deque(deque&&, const Allocator&);
     deque(initializer_list<T>, const Allocator& = Allocator());
     ~deque();
     deque& operator=(const deque& x);
     deque& operator=(deque&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
     deque& operator=(initializer_list<T>);
     template<class InputIterator>
       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
@@ -529,18 +547,24 @@ namespace std {
     template<class... Args> reference emplace_back(Args&&... args);
     template<class... Args> iterator emplace(const_iterator position, Args&&... args);
     void push_front(const T& x);
     void push_front(T&& x);
     void push_back(const T& x);
     void push_back(T&& x);
     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>);
     void pop_front();
     void pop_back();
@@ -553,14 +577,13 @@ namespace std {
   template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     deque(InputIterator, InputIterator, Allocator = Allocator())
       -> deque<iter-value-type<InputIterator>, Allocator>;
- // swap
-  template<class T, class Allocator>
-    void swap(deque<T, Allocator>& x, deque<T, Allocator>& y)
-      noexcept(noexcept(x.swap(y)));
 }
 ```
 #### Constructors, copy, and assignment <a id="deque.cons">[[deque.cons]]</a>
@@ -574,26 +597,26 @@ explicit deque(const Allocator&);
 ``` cpp
 explicit deque(size_type n, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `deque` with `n` default-inserted elements using
 the specified allocator.
-*Preconditions:* `T` is *Cpp17DefaultInsertable* into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
 deque(size_type n, const T& value, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `deque` with `n` copies of `value`, using the
 specified allocator.
-*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
 template<class InputIterator>
   deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
@@ -602,10 +625,20 @@ template<class InputIterator>
 *Effects:* Constructs a `deque` equal to the range \[`first`, `last`),
 using the specified allocator.
 *Complexity:* Linear in `distance(first, last)`.
 #### Capacity <a id="deque.capacity">[[deque.capacity]]</a>
 ``` cpp
 void resize(size_type sz);
 ```
@@ -657,39 +690,45 @@ 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>);
 template<class... Args> reference emplace_front(Args&&... args);
 template<class... Args> reference emplace_back(Args&&... args);
 template<class... Args> iterator emplace(const_iterator position, Args&&... args);
 void push_front(const T& x);
 void push_front(T&& x);
 void push_back(const T& x);
 void push_back(T&& x);
 ```
 *Effects:* An insertion in the middle of the deque invalidates all the
 iterators and references to elements of the deque. An insertion at
 either end of the deque invalidates all the iterators to the deque, but
 has no effect on the validity of references to elements of the deque.
 *Remarks:* If an exception is thrown other than by the copy constructor,
 move constructor, assignment operator, or move assignment operator of
 `T` there are no effects. If an exception is thrown while inserting a
 single element at either end, there are no effects. Otherwise, if an
 exception is thrown by the move constructor of a
 non-*Cpp17CopyInsertable* `T`, the effects are unspecified.
-*Complexity:* The complexity is linear in the number of elements
-inserted plus the lesser of the distances to the beginning and end of
-the deque. Inserting a single element at either the beginning or end of
-a deque always takes constant time and causes a single call to a
-constructor of `T`.
 ``` cpp
 iterator erase(const_iterator position);
 iterator erase(const_iterator first, const_iterator last);
 void pop_front();
 void pop_back();
@@ -705,19 +744,19 @@ invalidates the past-the-end iterator and all iterators and references
 to all the elements of the deque.
 [*Note 1*: `pop_front` and `pop_back` are erase
 operations. — *end note*]
 *Complexity:* The number of calls to the destructor of `T` is the same
 as the number of elements erased, but the number of calls to the
 assignment operator of `T` is no more than the lesser of the number of
 elements before the erased elements and the number of elements after the
 erased elements.
-*Throws:* Nothing unless an exception is thrown by the assignment
-operator of `T`.
 #### Erasure <a id="deque.erasure">[[deque.erasure]]</a>
 ``` cpp
 template<class T, class Allocator, class U>
   typename deque<T, Allocator>::size_type
@@ -746,39 +785,38 @@ auto it = remove_if(c.begin(), c.end(), pred);
 auto r = distance(it, c.end());
 c.erase(it, c.end());
 return r;
 ```
-### 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
-be open at the beginning. — *end note*]
 ``` cpp
 namespace std {
   template<class T, class Allocator = allocator<T>>
   class forward_list {
@@ -788,39 +826,43 @@ namespace std {
     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; // see [container.requirements]
-    using difference_type = implementation-defined; // 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]
-    // [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());
     ~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);
     void assign(size_type n, const T& t);
     void assign(initializer_list<T>);
     allocator_type get_allocator() const noexcept;
-    // [forwardlist.iter], iterators
     iterator before_begin() noexcept;
     const_iterator before_begin() const noexcept;
     iterator begin() noexcept;
     const_iterator begin() const noexcept;
     iterator end() noexcept;
@@ -832,39 +874,43 @@ namespace std {
     // capacity
     [[nodiscard]] bool empty() const noexcept;
     size_type max_size() const noexcept;
-    // [forwardlist.access], element access
     reference front();
     const_reference front() const;
-    // [forwardlist.modifiers], modifiers
     template<class... Args> reference emplace_front(Args&&... args);
     void push_front(const T& x);
     void push_front(T&& x);
     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);
     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;
-    // [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,
@@ -891,24 +937,23 @@ namespace std {
   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&);
 ```
@@ -947,36 +992,46 @@ template<class InputIterator>
 *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;
 ```
-*Returns:* A non-dereferenceable iterator that, when incremented, is
-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`.
-#### 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`
@@ -997,74 +1052,114 @@ void push_front(const T& x);
 void push_front(T&& x);
 ```
 *Effects:* Inserts a copy of `x` at the beginning of the list.
 ``` cpp
 void pop_front();
 ```
 *Effects:* As if by `erase_after(before_begin())`.
 ``` 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
-`position` if `n == 0`.
 ``` 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
-`position` if `first == last`.
 ``` cpp
 iterator insert_after(const_iterator position, initializer_list<T> il);
 ```
-*Effects:* `insert_after(p, il.begin(), il.end())`.
-*Returns:* An iterator pointing to the last inserted element or
-`position` if `il` is empty.
 ``` 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`.
 *Returns:* An iterator pointing to the new object.
 ``` cpp
 iterator erase_after(const_iterator position);
@@ -1121,16 +1216,20 @@ 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);
 ```
@@ -1206,61 +1305,66 @@ 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,
-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);
 ```
 *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);
 ```
@@ -1268,15 +1372,15 @@ 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
 void reverse() noexcept;
 ```
 *Effects:* Reverses the order of the elements in the list. Does not
@@ -1311,19 +1415,21 @@ 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 {
@@ -1333,12 +1439,12 @@ namespace std {
     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; // see [container.requirements]
-    using difference_type        = implementation-defined; // see [container.requirements]
     using iterator               = implementation-defined  // type of list::iterator; // see [container.requirements]
     using const_iterator         = implementation-defined  // type of list::const_iterator; // see [container.requirements]
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
@@ -1347,22 +1453,26 @@ namespace std {
     explicit list(const Allocator&);
     explicit list(size_type n, const Allocator& = Allocator());
     list(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
       list(InputIterator first, InputIterator last, const Allocator& = Allocator());
     list(const list& x);
     list(list&& x);
-    list(const list&, const Allocator&);
-    list(list&&, const Allocator&);
     list(initializer_list<T>, const Allocator& = Allocator());
     ~list();
     list& operator=(const list& x);
     list& operator=(list&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
     list& operator=(initializer_list<T>);
     template<class InputIterator>
       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
@@ -1396,21 +1506,27 @@ namespace std {
     // [list.modifiers], modifiers
     template<class... Args> reference emplace_front(Args&&... args);
     template<class... Args> reference emplace_back(Args&&... args);
     void push_front(const T& x);
     void push_front(T&& x);
     void pop_front();
     void push_back(const T& x);
     void push_back(T&& x);
     void pop_back();
     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);
@@ -1444,14 +1560,13 @@ namespace std {
   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
@@ -1497,10 +1612,20 @@ template<class InputIterator>
 *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);
 ```
@@ -1543,30 +1668,36 @@ 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>);
 template<class... Args> reference emplace_front(Args&&... args);
 template<class... Args> reference emplace_back(Args&&... args);
 template<class... Args> iterator emplace(const_iterator position, Args&&... args);
 void push_front(const T& x);
 void push_front(T&& x);
 void push_back(const T& x);
 void push_back(T&& x);
 ```
-*Remarks:* Does not affect the validity of iterators and references. If
-an exception is thrown there are no effects.
 *Complexity:* Insertion of a single element into a list takes constant
 time and exactly one call to a constructor of `T`. Insertion of multiple
 elements into a list is linear in the number of elements inserted, and
 the number of calls to the copy constructor or move constructor of `T`
 is exactly equal to the number of elements inserted.
 ``` cpp
 iterator erase(const_iterator position);
 iterator erase(const_iterator first, const_iterator last);
 void pop_front();
@@ -1585,15 +1716,18 @@ 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()`.
@@ -1668,67 +1802,64 @@ 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,
-otherwise no applications of the predicate.
 ``` cpp
 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);
 ```
-*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;
 ```
@@ -1745,14 +1876,14 @@ 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
@@ -1777,21 +1908,21 @@ template<class T, class Allocator, class Predicate>
 A `vector` is a sequence container that supports (amortized) constant
 time insert and erase operations at the end; insert and erase in the
 middle take linear time. Storage management is handled automatically,
 though hints can be given to improve efficiency.
-A `vector` meets all of the requirements of a container and 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]], of an
-allocator-aware container ([[container.alloc.req]]), and, for an
-element type other than `bool`, of a contiguous container
-[[container.requirements.general]]. The exceptions are the `push_front`,
-`pop_front`, and `emplace_front` member functions, which are not
-provided. Descriptions are provided here only for operations on `vector`
-that are not described in one of these tables or for operations where
-there is additional semantic information.
 The types `iterator` and `const_iterator` meet the constexpr iterator
 requirements [[iterator.requirements.general]].
 ``` cpp
@@ -1804,12 +1935,12 @@ namespace std {
     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; // see [container.requirements]
-    using difference_type        = implementation-defined; // see [container.requirements]
     using iterator               = implementation-defined  // type of vector::iterator; // see [container.requirements]
     using const_iterator         = implementation-defined  // type of vector::const_iterator; // see [container.requirements]
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
@@ -1818,23 +1949,27 @@ namespace std {
     constexpr explicit vector(const Allocator&) noexcept;
     constexpr explicit vector(size_type n, const Allocator& = Allocator());
     constexpr vector(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
       constexpr vector(InputIterator first, InputIterator last, const Allocator& = Allocator());
     constexpr vector(const vector& x);
     constexpr vector(vector&&) noexcept;
-    constexpr vector(const vector&, const Allocator&);
-    constexpr vector(vector&&, const Allocator&);
     constexpr vector(initializer_list<T>, const Allocator& = Allocator());
     constexpr ~vector();
     constexpr vector& operator=(const vector& x);
     constexpr vector& operator=(vector&& x)
       noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
                allocator_traits<Allocator>::is_always_equal::value);
     constexpr vector& operator=(initializer_list<T>);
     template<class InputIterator>
       constexpr void assign(InputIterator first, InputIterator last);
     constexpr void assign(size_type n, const T& u);
     constexpr void assign(initializer_list<T>);
     constexpr allocator_type get_allocator() const noexcept;
     // iterators
@@ -1878,19 +2013,23 @@ namespace std {
     // [vector.modifiers], modifiers
     template<class... Args> constexpr reference emplace_back(Args&&... args);
     constexpr void push_back(const T& x);
     constexpr void push_back(T&& x);
     constexpr void pop_back();
     template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);
     constexpr iterator insert(const_iterator position, const T& x);
     constexpr iterator insert(const_iterator position, T&& x);
     constexpr iterator insert(const_iterator position, size_type n, const T& x);
     template<class InputIterator>
       constexpr iterator insert(const_iterator position,
                                 InputIterator first, InputIterator last);
     constexpr iterator insert(const_iterator position, initializer_list<T> il);
     constexpr iterator erase(const_iterator position);
     constexpr iterator erase(const_iterator first, const_iterator last);
     constexpr void     swap(vector&)
       noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
@@ -1900,23 +2039,22 @@ namespace std {
   template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     vector(InputIterator, InputIterator, Allocator = Allocator())
       -> vector<iter-value-type<InputIterator>, Allocator>;
- // swap
-  template<class T, class Allocator>
-    constexpr void swap(vector<T, Allocator>& x, vector<T, Allocator>& y)
-      noexcept(noexcept(x.swap(y)));
 }
 ```
 An incomplete type `T` may be used when instantiating `vector` if the
 allocator meets the allocator completeness requirements
 [[allocator.requirements.completeness]]. `T` shall be complete before
 any member of the resulting specialization of `vector` is referenced.
-#### Constructors, copy, and assignment <a id="vector.cons">[[vector.cons]]</a>
 ``` cpp
 constexpr explicit vector(const Allocator&) noexcept;
 ```
@@ -1957,12 +2095,27 @@ template<class InputIterator>
 using the specified allocator.
 *Complexity:* Makes only N calls to the copy constructor of `T` (where N
 is the distance between `first` and `last`) and no reallocations if
 iterators `first` and `last` are of forward, bidirectional, or random
-access categories. It makes order `N` calls to the copy constructor of
-`T` and order log N reallocations if they are just input iterators.
 #### Capacity <a id="vector.capacity">[[vector.capacity]]</a>
 ``` cpp
 constexpr size_type capacity() const noexcept;
@@ -1986,15 +2139,15 @@ size, so that it can manage the storage allocation accordingly. After
 `capacity()` otherwise. Reallocation happens at this point if and only
 if the current capacity is less than the argument of `reserve()`. If an
 exception is thrown other than by the move constructor of a
 non-*Cpp17CopyInsertable* type, there are no effects.
 *Complexity:* It does not change the size of the sequence and takes at
 most linear time in the size of the sequence.
-*Throws:* `length_error` if `n > max_size()`.[^4]
 *Remarks:* Reallocation invalidates all the references, pointers, and
 iterators referring to the elements in the sequence, as well as the
 past-the-end iterator.
 [*Note 1*: If no reallocation happens, they remain
@@ -2085,18 +2238,26 @@ range. For a non-empty vector, `data()` `==` `addressof(front())`.
 constexpr iterator insert(const_iterator position, const T& x);
 constexpr iterator insert(const_iterator position, T&& x);
 constexpr iterator insert(const_iterator position, size_type n, const T& x);
 template<class InputIterator>
   constexpr iterator insert(const_iterator position, InputIterator first, InputIterator last);
 constexpr iterator insert(const_iterator position, initializer_list<T>);
 template<class... Args> constexpr reference emplace_back(Args&&... args);
 template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);
 constexpr void push_back(const T& x);
 constexpr void push_back(T&& x);
 ```
 *Remarks:* Causes reallocation if the new size is greater than the old
 capacity. Reallocation invalidates all the references, pointers, and
 iterators referring to the elements in the sequence, as well as the
 past-the-end iterator. If no reallocation happens, then references,
 pointers, and iterators before the insertion point remain valid but
@@ -2108,31 +2269,27 @@ no effects. If an exception is thrown while inserting a single element
 at the end and `T` is *Cpp17CopyInsertable* or
 `is_nothrow_move_constructible_v<T>` is `true`, there are no effects.
 Otherwise, if an exception is thrown by the move constructor of a
 non-*Cpp17CopyInsertable* `T`, the effects are unspecified.
-*Complexity:* If reallocation happens, linear in the number of elements
-of the resulting vector; otherwise, linear in the number of elements
-inserted plus the distance to the end of the vector.
 ``` cpp
 constexpr iterator erase(const_iterator position);
 constexpr iterator erase(const_iterator first, const_iterator last);
 constexpr void pop_back();
 ```
 *Effects:* Invalidates iterators and references at or after the point of
 the erase.
 *Complexity:* The destructor of `T` is called the number of times equal
 to the number of the elements erased, but the assignment operator of `T`
 is called the number of times equal to the number of elements in the
 vector after the erased elements.
-*Throws:* Nothing unless an exception is thrown by the assignment
-operator or move assignment operator of `T`.
 #### Erasure <a id="vector.erasure">[[vector.erasure]]</a>
 ``` cpp
 template<class T, class Allocator, class U>
   constexpr typename vector<T, Allocator>::size_type
@@ -2161,64 +2318,74 @@ auto it = remove_if(c.begin(), c.end(), pred);
 auto r = distance(it, c.end());
 c.erase(it, c.end());
 return r;
 ```
-### Class `vector<bool>` <a id="vector.bool">[[vector.bool]]</a>
-To optimize space allocation, a specialization of vector for `bool`
-elements is provided:
 ``` cpp
 namespace std {
   template<class Allocator>
   class vector<bool, Allocator> {
   public:
     // types
     using value_type             = bool;
     using allocator_type         = Allocator;
-    using pointer                = implementation-defined;
-    using const_pointer          = implementation-defined;
     using const_reference        = bool;
-    using size_type              = implementation-defined; // see [container.requirements]
-    using difference_type        = implementation-defined; // see [container.requirements]
     using iterator               = implementation-defined  // type of vector<bool>::iterator; // see [container.requirements]
     using const_iterator         = implementation-defined  // type of vector<bool>::const_iterator; // see [container.requirements]
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     // bit reference
     class reference {
       friend class vector;
       constexpr reference() noexcept;
     public:
       constexpr reference(const reference&) = default;
       constexpr ~reference();
       constexpr operator bool() const noexcept;
-      constexpr reference& operator=(const bool x) noexcept;
       constexpr reference& operator=(const reference& x) noexcept;
       constexpr void flip() noexcept;   // flips the bit
     };
     // construct/copy/destroy
-    constexpr vector() : vector(Allocator()) { }
-    constexpr explicit vector(const Allocator&);
     constexpr explicit vector(size_type n, const Allocator& = Allocator());
     constexpr vector(size_type n, const bool& value, const Allocator& = Allocator());
     template<class InputIterator>
       constexpr vector(InputIterator first, InputIterator last, const Allocator& = Allocator());
     constexpr vector(const vector& x);
-    constexpr vector(vector&& x);
-    constexpr vector(const vector&, const Allocator&);
-    constexpr vector(vector&&, const Allocator&);
-    constexpr vector(initializer_list<bool>, const Allocator& = Allocator()));
     constexpr ~vector();
     constexpr vector& operator=(const vector& x);
-    constexpr vector& operator=(vector&& x);
     constexpr vector& operator=(initializer_list<bool>);
     template<class InputIterator>
       constexpr void assign(InputIterator first, InputIterator last);
     constexpr void assign(size_type n, const bool& t);
     constexpr void assign(initializer_list<bool>);
     constexpr allocator_type get_allocator() const noexcept;
     // iterators
@@ -2256,23 +2423,29 @@ namespace std {
     constexpr const_reference back() const;
     // modifiers
     template<class... Args> constexpr reference emplace_back(Args&&... args);
     constexpr void push_back(const bool& x);
     constexpr void pop_back();
     template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);
     constexpr iterator insert(const_iterator position, const bool& x);
     constexpr iterator insert(const_iterator position, size_type n, const bool& x);
     template<class InputIterator>
       constexpr iterator insert(const_iterator position,
                                 InputIterator first, InputIterator last);
     constexpr iterator insert(const_iterator position, initializer_list<bool> il);
     constexpr iterator erase(const_iterator position);
     constexpr iterator erase(const_iterator first, const_iterator last);
-    constexpr void swap(vector&);
-    constexpr static void swap(reference x, reference y) noexcept;
     constexpr void flip() noexcept;     // flips all bits
     constexpr void clear() noexcept;
   };
 }
 ```
@@ -2289,22 +2462,22 @@ recommended instead.
 `reference`
 is a class that simulates the behavior of references of a single bit in
 `vector<bool>`. The conversion function returns `true` when the bit is
-set, and `false` otherwise. The assignment operator sets the bit when
-the argument is (convertible to) `true` and clears it otherwise. `flip`
 reverses the state of the bit.
 ``` cpp
 constexpr void flip() noexcept;
 ```
 *Effects:* Replaces each element in the container with its complement.
 ``` cpp
-constexpr static void swap(reference x, reference y) noexcept;
 ```
 *Effects:* Exchanges the contents of `x` and `y` as if by:
 ``` cpp
@@ -2317,5 +2490,52 @@ y = b;
 template<class Allocator> struct hash<vector<bool, Allocator>>;
 ```
 The specialization is enabled [[unord.hash]].

   template<class T, class Allocator>
     void swap(deque<T, Allocator>& x, deque<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
+  // [deque.erasure], erasure
   template<class T, class Allocator, class U>
     typename deque<T, Allocator>::size_type
       erase(deque<T, Allocator>& c, const U& value);
   template<class T, class Allocator, class Predicate>
     typename deque<T, Allocator>::size_type
 ``` cpp
 #include <compare>              // see [compare.syn]
 #include <initializer_list>     // see [initializer.list.syn]
 namespace std {
+  // [forward.list], class template forward_list
   template<class T, class Allocator = allocator<T>> class forward_list;
   template<class T, class Allocator>
     bool operator==(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
   template<class T, class Allocator>
   template<class T, class Allocator>
     void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
+  // [forward.list.erasure], erasure
   template<class T, class Allocator, class U>
     typename forward_list<T, Allocator>::size_type
       erase(forward_list<T, Allocator>& c, const U& value);
   template<class T, class Allocator, class Predicate>
     typename forward_list<T, Allocator>::size_type
   template<class T, class Allocator>
     void swap(list<T, Allocator>& x, list<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
+  // [list.erasure], erasure
   template<class T, class Allocator, class U>
     typename list<T, Allocator>::size_type
       erase(list<T, Allocator>& c, const U& value);
   template<class T, class Allocator, class Predicate>
     typename list<T, Allocator>::size_type
   template<class T, class Allocator>
     constexpr void swap(vector<T, Allocator>& x, vector<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
+  // [vector.erasure], erasure
   template<class T, class Allocator, class U>
     constexpr typename vector<T, Allocator>::size_type
       erase(vector<T, Allocator>& c, const U& value);
   template<class T, class Allocator, class Predicate>
     constexpr typename vector<T, Allocator>::size_type
       erase_if(vector<T, Allocator>& c, Predicate pred);
+ namespace pmr {
+ template<class T>
+      using vector = std::vector<T, polymorphic_allocator<T>>;
+  }
+  // [vector.bool], specialization of vector for bool
+  // [vector.bool.pspc], partial class template specialization vector<bool, Allocator>
+  template<class Allocator>
+    class vector<bool, Allocator>;
+  template<class T>
+    constexpr bool is-vector-bool-reference = see below;          // exposition only
   // hash support
   template<class T> struct hash;
   template<class Allocator> struct hash<vector<bool, Allocator>>;
+ // [vector.bool.fmt], formatter specialization for vector<bool>
+ template<class T, class charT> requires is-vector-bool-reference<T>
+    struct formatter<T, charT>;
 }
 ```
 ### Class template `array` <a id="array">[[array]]</a>
 #### Overview <a id="array.overview">[[array.overview]]</a>
 The header `<array>` defines a class template for storing fixed-size
 sequences of objects. An `array` is a contiguous container
+[[container.reqmts]]. An instance of `array<T, N>` stores `N` elements
+of type `T`, so that `size() == N` is an invariant.
 An `array` is an aggregate [[dcl.init.aggr]] that can be
 list-initialized with up to `N` elements whose types are convertible to
 `T`.
+An `array` meets all of the requirements of a container
+[[container.reqmts]] and of a reversible container
+[[container.rev.reqmts]], except that a default constructed `array`
+object is not empty if `N` > 0. An `array` meets some of the
+requirements of a sequence container [[sequence.reqmts]]. Descriptions
+are provided here only for operations on `array` that are not described
+in one of these tables and for operations where there is additional
+semantic information.
 `array<T, N>` is a structural type [[temp.param]] if `T` is a structural
 type. Two values `a1` and `a2` of type `array<T, N>` are
 template-argument-equivalent [[temp.type]] if and only if each pair of
 corresponding elements in `a1` and `a2` are
 ```
 #### Constructors, copy, and assignment <a id="array.cons">[[array.cons]]</a>
 The conditions for an aggregate [[dcl.init.aggr]] shall be met. Class
+`array` relies on the implicitly-declared special member functions
+[[class.default.ctor]], [[class.dtor]], [[class.copy.ctor]] to conform
+to the container requirements table in  [[container.requirements]]. In
+addition to the requirements specified in the container requirements
+table, the implicit move constructor and move assignment operator for
+`array` require that `T` be *Cpp17MoveConstructible* or
+*Cpp17MoveAssignable*, respectively.
 ``` cpp
 template<class T, class... U>
   array(T, U...) -> array<T, 1 + sizeof...(U)>;
 ```
 ```
 *Effects:* Equivalent to `swap_ranges(begin(), end(), y.begin())`.
 [*Note 1*: Unlike the `swap` function for other containers,
+`array::swap` takes linear time, can exit via an exception, and does not
 cause iterators to become associated with the other
 container. — *end note*]
 #### Specialized algorithms <a id="array.special">[[array.special]]</a>
 insert and erase operations at the beginning or the end; insert and
 erase in the middle take linear time. That is, a deque is especially
 optimized for pushing and popping elements at the beginning and end.
 Storage management is handled automatically.
+A `deque` meets all of the requirements of a container
+[[container.reqmts]], of a reversible container
+[[container.rev.reqmts]], of an allocator-aware container
+[[container.alloc.reqmts]], and of a sequence container, including the
+optional sequence container requirements [[sequence.reqmts]].
+Descriptions are provided here only for operations on `deque` 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 deque {
     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 deque::size_type; // see [container.requirements]
+    using difference_type        = implementation-defined  // type of deque::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of deque::iterator; // see [container.requirements]
     using const_iterator         = implementation-defined  // type of deque::const_iterator; // see [container.requirements]
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     explicit deque(const Allocator&);
     explicit deque(size_type n, const Allocator& = Allocator());
     deque(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
       deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
+    template<container-compatible-range<T> R>
+      deque(from_range_t, R&& rg, const Allocator& = Allocator());
     deque(const deque& x);
     deque(deque&&);
+    deque(const deque&, const type_identity_t<Allocator>&);
+    deque(deque&&, const type_identity_t<Allocator>&);
     deque(initializer_list<T>, const Allocator& = Allocator());
     ~deque();
     deque& operator=(const deque& x);
     deque& operator=(deque&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
     deque& 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;
     // iterators
     template<class... Args> reference emplace_back(Args&&... args);
     template<class... Args> iterator emplace(const_iterator position, 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 push_back(const T& x);
     void push_back(T&& x);
+    template<container-compatible-range<T> R>
+      void append_range(R&& rg);
     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);
+    template<container-compatible-range<T> R>
+      iterator insert_range(const_iterator position, R&& rg);
     iterator insert(const_iterator position, initializer_list<T>);
     void pop_front();
     void pop_back();
   template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     deque(InputIterator, InputIterator, Allocator = Allocator())
       -> deque<iter-value-type<InputIterator>, Allocator>;
+ template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+    deque(from_range_t, R&&, Allocator = Allocator())
+      -> deque<ranges::range_value_t<R>, Allocator>;
 }
 ```
 #### Constructors, copy, and assignment <a id="deque.cons">[[deque.cons]]</a>
 ``` cpp
 explicit deque(size_type n, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `*this`.
 *Effects:* Constructs a `deque` with `n` default-inserted elements using
 the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 deque(size_type n, const T& value, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* Constructs a `deque` with `n` copies of `value`, using the
 specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 template<class InputIterator>
   deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
 *Effects:* Constructs a `deque` equal to the range \[`first`, `last`),
 using the specified allocator.
 *Complexity:* Linear in `distance(first, last)`.
+``` cpp
+template<container-compatible-range<T> R>
+  deque(from_range_t, R&& rg, const Allocator& = Allocator());
+```
+*Effects:* Constructs a `deque` with the elements of the range `rg`,
+using the specified allocator.
+*Complexity:* Linear in `ranges::distance(rg)`.
 #### Capacity <a id="deque.capacity">[[deque.capacity]]</a>
 ``` cpp
 void resize(size_type sz);
 ```
 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);
+template<container-compatible-range<T> R>
+  iterator insert_range(const_iterator position, R&& rg);
 iterator insert(const_iterator position, initializer_list<T>);
 template<class... Args> reference emplace_front(Args&&... args);
 template<class... Args> reference emplace_back(Args&&... args);
 template<class... Args> iterator emplace(const_iterator position, 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 push_back(const T& x);
 void push_back(T&& x);
+template<container-compatible-range<T> R>
+  void append_range(R&& rg);
 ```
 *Effects:* An insertion in the middle of the deque invalidates all the
 iterators and references to elements of the deque. An insertion at
 either end of the deque invalidates all the iterators to the deque, but
 has no effect on the validity of references to elements of the deque.
+*Complexity:* The complexity is linear in the number of elements
+inserted plus the lesser of the distances to the beginning and end of
+the deque. Inserting a single element at either the beginning or end of
+a deque always takes constant time and causes a single call to a
+constructor of `T`.
 *Remarks:* If an exception is thrown other than by the copy constructor,
 move constructor, assignment operator, or move assignment operator of
 `T` there are no effects. If an exception is thrown while inserting a
 single element at either end, there are no effects. Otherwise, if an
 exception is thrown by the move constructor of a
 non-*Cpp17CopyInsertable* `T`, the effects are unspecified.
 ``` cpp
 iterator erase(const_iterator position);
 iterator erase(const_iterator first, const_iterator last);
 void pop_front();
 void pop_back();
 to all the elements of the deque.
 [*Note 1*: `pop_front` and `pop_back` are erase
 operations. — *end note*]
+*Throws:* Nothing unless an exception is thrown by the assignment
+operator of `T`.
 *Complexity:* The number of calls to the destructor of `T` is the same
 as the number of elements erased, but the number of calls to the
 assignment operator of `T` is no more than the lesser of the number of
 elements before the erased elements and the number of elements after the
 erased elements.
 #### Erasure <a id="deque.erasure">[[deque.erasure]]</a>
 ``` cpp
 template<class T, class Allocator, class U>
   typename deque<T, Allocator>::size_type
 auto r = distance(it, c.end());
 c.erase(it, c.end());
 return r;
 ```
+### Class template `forward_list` <a id="forward.list">[[forward.list]]</a>
+#### Overview <a id="forward.list.overview">[[forward.list.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.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
+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,
+`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 {
     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;
     // 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,
   template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     forward_list(InputIterator, InputIterator, Allocator = Allocator())
       -> forward_list<iter-value-type<InputIterator>, Allocator>;
+ template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+    forward_list(from_range_t, R&&, Allocator = Allocator())
+      -> forward_list<ranges::range_value_t<R>, Allocator>;
 }
 ```
 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="forward.list.cons">[[forward.list.cons]]</a>
 ``` cpp
 explicit forward_list(const 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()`.
+*Returns:* A non-dereferenceable iterator that, when incremented, is
+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`
 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()`).
+*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()`).
 *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()`).
 *Effects:* Inserts `n` copies of `x` after `position`.
+*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`
 are iterators in `*this`.
 *Effects:* Inserts copies of elements in \[`first`, `last`) after
 `position`.
+*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
+`*this` do not overlap.
+*Effects:* Inserts copies of elements in the range `rg` after
+`position`.
+*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()`).
+*Effects:* Inserts an object of type `value_type`
+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);
 *Effects:* Erases all elements in the range \[`begin()`, `end()`).
 *Remarks:* Does not invalidate past-the-end iterators.
+#### Operations <a id="forward.list.ops">[[forward.list.ops]]</a>
 In this subclause, arguments for a template parameter named `Predicate`
 or `BinaryPredicate` shall meet the corresponding requirements in
+[[algorithms.requirements]]. The semantics of `i + n`, where `i` is an
+iterator into the list and `n` is an integer, are the same as those of
+`next(i, n)`. The expression `i - n`, where `i` is an iterator into the
+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);
 ```
 *Returns:* The number of elements erased.
 *Throws:* Nothing unless an exception is thrown by the equality
 comparison or the predicate.
 *Complexity:* Exactly `distance(begin(), end())` applications of the
 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.
 *Effects:* Erases all but the first element from every consecutive group
+of equivalent elements. That is, for a nonempty list, erases all
+elements referred to by the iterator `i` in the range \[`begin() + 1`,
+`end()`) for which `binary_pred(*i, *(i - 1))` is `true`. 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 predicate.
+*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
+comparator `comp`, and `get_allocator() == x.get_allocator()` is `true`.
+*Effects:* If `addressof(x) == this`, there are no effects. Otherwise,
+merges the two sorted ranges \[`begin()`, `end()`) and \[`x.begin()`,
+`x.end()`). The result is a range that is sorted with respect to the
+comparator `comp`. 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`.
 *Complexity:* At most
 `distance(begin(), end()) + distance(x.begin(), x.end()) - 1`
+comparisons if `addressof(x) != this`; otherwise, no comparisons are
+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
 references.
 *Complexity:* Approximately N log N comparisons, where N is
 `distance(begin(), end())`.
+*Remarks:* Stable [[algorithm.stable]].
 ``` cpp
 void reverse() noexcept;
 ```
 *Effects:* Reverses the order of the elements in the list. Does not
 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
+[[container.reqmts]], of a reversible container
+[[container.rev.reqmts]], of an allocator-aware container
+[[container.alloc.reqmts]], and of a sequence container, including most
+of the optional sequence container requirements [[sequence.reqmts]]. 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 {
     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 list::size_type; // see [container.requirements]
+    using difference_type        = implementation-defined  // type of list::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of list::iterator; // see [container.requirements]
     using const_iterator         = implementation-defined  // type of list::const_iterator; // see [container.requirements]
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     explicit list(const Allocator&);
     explicit list(size_type n, const Allocator& = Allocator());
     list(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
       list(InputIterator first, InputIterator last, const Allocator& = Allocator());
+    template<container-compatible-range<T> R>
+      list(from_range_t, R&& rg, const Allocator& = Allocator());
     list(const list& x);
     list(list&& x);
+    list(const list&, const type_identity_t<Allocator>&);
+    list(list&&, const type_identity_t<Allocator>&);
     list(initializer_list<T>, const Allocator& = Allocator());
     ~list();
     list& operator=(const list& x);
     list& operator=(list&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
     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;
     // iterators
     // [list.modifiers], modifiers
     template<class... Args> reference emplace_front(Args&&... args);
     template<class... Args> reference emplace_back(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();
     void push_back(const T& x);
     void push_back(T&& x);
+    template<container-compatible-range<T> R>
+      void append_range(R&& rg);
     void pop_back();
     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);
+    template<container-compatible-range<T> R>
+      iterator insert_range(const_iterator position, R&& rg);
     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);
   template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     list(InputIterator, InputIterator, Allocator = Allocator())
       -> list<iter-value-type<InputIterator>, Allocator>;
+ template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+    list(from_range_t, R&&, Allocator = Allocator())
+      -> list<ranges::range_value_t<R>, Allocator>;
 }
 ```
 An incomplete type `T` may be used when instantiating `list` if the
 allocator meets the allocator completeness requirements
 *Effects:* Constructs a `list` equal to the range \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
+``` cpp
+template<container-compatible-range<T> R>
+  list(from_range_t, R&& rg, const Allocator& = Allocator());
+```
+*Effects:* Constructs a `list` object with the elements of the range
+`rg`.
+*Complexity:* Linear in `ranges::distance(rg)`.
 #### Capacity <a id="list.capacity">[[list.capacity]]</a>
 ``` cpp
 void resize(size_type sz);
 ```
 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);
+template<container-compatible-range<T> R>
+  iterator insert_range(const_iterator position, R&& rg);
 iterator insert(const_iterator position, initializer_list<T>);
 template<class... Args> reference emplace_front(Args&&... args);
 template<class... Args> reference emplace_back(Args&&... args);
 template<class... Args> iterator emplace(const_iterator position, 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 push_back(const T& x);
 void push_back(T&& x);
+template<container-compatible-range<T> R>
+  void append_range(R&& rg);
 ```
 *Complexity:* Insertion of a single element into a list takes constant
 time and exactly one call to a constructor of `T`. Insertion of multiple
 elements into a list is linear in the number of elements inserted, and
 the number of calls to the copy constructor or move constructor of `T`
 is exactly equal to the number of elements inserted.
+*Remarks:* Does not affect the validity of iterators and references. If
+an exception is thrown there are no effects.
 ``` cpp
 iterator erase(const_iterator position);
 iterator erase(const_iterator first, const_iterator last);
 void pop_front();
 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]]. The semantics of `i + n` and `i - n`, where
+`i` is an iterator into the list and `n` is an integer, are the same as
+those of `next(i, n)` and `prev(i, n)`, respectively. 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()`.
 *Returns:* The number of elements erased.
 *Throws:* Nothing unless an exception is thrown by `*i == value` or
 `pred(*i) != false`.
 *Complexity:* Exactly `size()` applications of the 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.
 *Effects:* Erases all but the first element from every consecutive group
+of equivalent elements. That is, for a nonempty list, erases all
+elements referred to by the iterator `i` in the range \[`begin() + 1`,
+`end()`) for which `binary_pred(*i, *(i - 1))` is `true`. 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 predicate.
+*Complexity:* If `empty()` is `false`, exactly `size() - 1` applications
+of the corresponding predicate, otherwise no applications of the
+predicate.
 ``` cpp
 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);
 ```
+Let `comp` be `less<>` for the first two overloads.
+*Preconditions:* `*this` and `x` are both sorted with respect to the
+comparator `comp`, and `get_allocator() == x.get_allocator()` is `true`.
+*Effects:* If `addressof(x) == this`, there are no effects. Otherwise,
+merges the two sorted ranges \[`begin()`, `end()`) and \[`x.begin()`,
+`x.end()`). The result is a range that is sorted with respect to the
+comparator `comp`. 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`.
+*Complexity:* At most `size() + x.size() - 1` comparisons if
+`addressof(x) != this`; otherwise, no comparisons are 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 reverse() noexcept;
 ```
 *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.
 *Complexity:* Approximately N log N comparisons, where `N == size()`.
+*Remarks:* Stable [[algorithm.stable]].
 #### Erasure <a id="list.erasure">[[list.erasure]]</a>
 ``` cpp
 template<class T, class Allocator, class U>
   typename list<T, Allocator>::size_type
 A `vector` is a sequence container that supports (amortized) constant
 time insert and erase operations at the end; insert and erase in the
 middle take linear time. Storage management is handled automatically,
 though hints can be given to improve efficiency.
+A `vector` meets all of the requirements of a container
+[[container.reqmts]], of a reversible container
+[[container.rev.reqmts]], of an allocator-aware container
+[[container.alloc.reqmts]], of a sequence container, including most of
+the optional sequence container requirements [[sequence.reqmts]], and,
+for an element type other than `bool`, of a contiguous container
+[[container.reqmts]]. The exceptions are the `push_front`,
+`prepend_range`, `pop_front`, and `emplace_front` member functions,
+which are not provided. Descriptions are provided here only for
+operations on `vector` that are not described in one of these tables or
+for operations where there is additional semantic information.
 The types `iterator` and `const_iterator` meet the constexpr iterator
 requirements [[iterator.requirements.general]].
 ``` cpp
     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 vector::size_type; // see [container.requirements]
+    using difference_type        = implementation-defined  // type of vector::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of vector::iterator; // see [container.requirements]
     using const_iterator         = implementation-defined  // type of vector::const_iterator; // see [container.requirements]
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     constexpr explicit vector(const Allocator&) noexcept;
     constexpr explicit vector(size_type n, const Allocator& = Allocator());
     constexpr vector(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
       constexpr vector(InputIterator first, InputIterator last, const Allocator& = Allocator());
+    template<container-compatible-range<T> R>
+      constexpr vector(from_range_t, R&& rg, const Allocator& = Allocator());
     constexpr vector(const vector& x);
     constexpr vector(vector&&) noexcept;
+    constexpr vector(const vector&, const type_identity_t<Allocator>&);
+    constexpr vector(vector&&, const type_identity_t<Allocator>&);
     constexpr vector(initializer_list<T>, const Allocator& = Allocator());
     constexpr ~vector();
     constexpr vector& operator=(const vector& x);
     constexpr vector& operator=(vector&& x)
       noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
                allocator_traits<Allocator>::is_always_equal::value);
     constexpr vector& 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& u);
     constexpr void assign(initializer_list<T>);
     constexpr allocator_type get_allocator() const noexcept;
     // iterators
     // [vector.modifiers], modifiers
     template<class... Args> constexpr reference emplace_back(Args&&... args);
     constexpr void push_back(const T& x);
     constexpr void push_back(T&& x);
+    template<container-compatible-range<T> R>
+      constexpr void append_range(R&& rg);
     constexpr void pop_back();
     template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);
     constexpr iterator insert(const_iterator position, const T& x);
     constexpr iterator insert(const_iterator position, T&& x);
     constexpr iterator insert(const_iterator position, size_type n, const T& x);
     template<class InputIterator>
       constexpr iterator insert(const_iterator position,
                                 InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R>
+      constexpr iterator insert_range(const_iterator position, R&& rg);
     constexpr iterator insert(const_iterator position, initializer_list<T> il);
     constexpr iterator erase(const_iterator position);
     constexpr iterator erase(const_iterator first, const_iterator last);
     constexpr void     swap(vector&)
       noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
   template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     vector(InputIterator, InputIterator, Allocator = Allocator())
       -> vector<iter-value-type<InputIterator>, Allocator>;
+ template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+    vector(from_range_t, R&&, Allocator = Allocator())
+      -> vector<ranges::range_value_t<R>, Allocator>;
 }
 ```
 An incomplete type `T` may be used when instantiating `vector` if the
 allocator meets the allocator completeness requirements
 [[allocator.requirements.completeness]]. `T` shall be complete before
 any member of the resulting specialization of `vector` is referenced.
+#### Constructors <a id="vector.cons">[[vector.cons]]</a>
 ``` cpp
 constexpr explicit vector(const Allocator&) noexcept;
 ```
 using the specified allocator.
 *Complexity:* Makes only N calls to the copy constructor of `T` (where N
 is the distance between `first` and `last`) and no reallocations if
 iterators `first` and `last` are of forward, bidirectional, or random
+access categories. It makes order N calls to the copy constructor of `T`
+and order log N reallocations if they are just input iterators.
+``` cpp
+template<container-compatible-range<T> R>
+  constexpr vector(from_range_t, R&& rg, const Allocator& = Allocator());
+```
+*Effects:* Constructs a `vector` object with the elements of the range
+`rg`, using the specified allocator.
+*Complexity:* Initializes exactly N elements from the results of
+dereferencing successive iterators of `rg`, where N is
+`ranges::distance(rg)`. Performs no reallocations if `R` models
+`ranges::forward_range` or `ranges::sized_range`; otherwise, performs
+order log N reallocations and order N calls to the copy or move
+constructor of `T`.
 #### Capacity <a id="vector.capacity">[[vector.capacity]]</a>
 ``` cpp
 constexpr size_type capacity() const noexcept;
 `capacity()` otherwise. Reallocation happens at this point if and only
 if the current capacity is less than the argument of `reserve()`. If an
 exception is thrown other than by the move constructor of a
 non-*Cpp17CopyInsertable* type, there are no effects.
+*Throws:* `length_error` if `n > max_size()`.[^4]
 *Complexity:* It does not change the size of the sequence and takes at
 most linear time in the size of the sequence.
 *Remarks:* Reallocation invalidates all the references, pointers, and
 iterators referring to the elements in the sequence, as well as the
 past-the-end iterator.
 [*Note 1*: If no reallocation happens, they remain
 constexpr iterator insert(const_iterator position, const T& x);
 constexpr iterator insert(const_iterator position, T&& x);
 constexpr iterator insert(const_iterator position, size_type n, const T& x);
 template<class InputIterator>
   constexpr iterator insert(const_iterator position, InputIterator first, InputIterator last);
+template<container-compatible-range<T> R>
+  constexpr iterator insert_range(const_iterator position, R&& rg);
 constexpr iterator insert(const_iterator position, initializer_list<T>);
 template<class... Args> constexpr reference emplace_back(Args&&... args);
 template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);
 constexpr void push_back(const T& x);
 constexpr void push_back(T&& x);
+template<container-compatible-range<T> R>
+  constexpr void append_range(R&& rg);
 ```
+*Complexity:* If reallocation happens, linear in the number of elements
+of the resulting vector; otherwise, linear in the number of elements
+inserted plus the distance to the end of the vector.
 *Remarks:* Causes reallocation if the new size is greater than the old
 capacity. Reallocation invalidates all the references, pointers, and
 iterators referring to the elements in the sequence, as well as the
 past-the-end iterator. If no reallocation happens, then references,
 pointers, and iterators before the insertion point remain valid but
 at the end and `T` is *Cpp17CopyInsertable* or
 `is_nothrow_move_constructible_v<T>` is `true`, there are no effects.
 Otherwise, if an exception is thrown by the move constructor of a
 non-*Cpp17CopyInsertable* `T`, the effects are unspecified.
 ``` cpp
 constexpr iterator erase(const_iterator position);
 constexpr iterator erase(const_iterator first, const_iterator last);
 constexpr void pop_back();
 ```
 *Effects:* Invalidates iterators and references at or after the point of
 the erase.
+*Throws:* Nothing unless an exception is thrown by the assignment
+operator or move assignment operator of `T`.
 *Complexity:* The destructor of `T` is called the number of times equal
 to the number of the elements erased, but the assignment operator of `T`
 is called the number of times equal to the number of elements in the
 vector after the erased elements.
 #### Erasure <a id="vector.erasure">[[vector.erasure]]</a>
 ``` cpp
 template<class T, class Allocator, class U>
   constexpr typename vector<T, Allocator>::size_type
 auto r = distance(it, c.end());
 c.erase(it, c.end());
 return r;
 ```
+### Specialization of `vector` for `bool` <a id="vector.bool">[[vector.bool]]</a>
+#### Partial class template specialization `vector<bool, Allocator>` <a id="vector.bool.pspc">[[vector.bool.pspc]]</a>
+To optimize space allocation, a partial specialization of `vector` for
+`bool` elements is provided:
 ``` cpp
 namespace std {
   template<class Allocator>
   class vector<bool, Allocator> {
   public:
     // types
     using value_type             = bool;
     using allocator_type         = Allocator;
+    using pointer                = implementation-defined  // type of vector<bool>::pointer;
+    using const_pointer          = implementation-defined  // type of vector<bool>::const_pointer;
     using const_reference        = bool;
+    using size_type              = implementation-defined  // type of vector<bool>::size_type; // see [container.requirements]
+    using difference_type        = implementation-defined  // type of vector<bool>::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of vector<bool>::iterator; // see [container.requirements]
     using const_iterator         = implementation-defined  // type of vector<bool>::const_iterator; // see [container.requirements]
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     // bit reference
     class reference {
       friend class vector;
       constexpr reference() noexcept;
     public:
       constexpr reference(const reference&) = default;
       constexpr ~reference();
       constexpr operator bool() const noexcept;
+      constexpr reference& operator=(bool x) noexcept;
       constexpr reference& operator=(const reference& x) noexcept;
+      constexpr const reference& operator=(bool x) const noexcept;
       constexpr void flip() noexcept;   // flips the bit
     };
     // construct/copy/destroy
+    constexpr vector() noexcept(noexcept(Allocator())) : vector(Allocator()) { }
+    constexpr explicit vector(const Allocator&) noexcept;
     constexpr explicit vector(size_type n, const Allocator& = Allocator());
     constexpr vector(size_type n, const bool& value, const Allocator& = Allocator());
     template<class InputIterator>
       constexpr vector(InputIterator first, InputIterator last, const Allocator& = Allocator());
+    template<container-compatible-range<bool> R>
+      constexpr vector(from_range_t, R&& rg, const Allocator& = Allocator());
     constexpr vector(const vector& x);
+    constexpr vector(vector&& x) noexcept;
+    constexpr vector(const vector&, const type_identity_t<Allocator>&);
+    constexpr vector(vector&&, const type_identity_t<Allocator>&);
+    constexpr vector(initializer_list<bool>, const Allocator& = Allocator());
     constexpr ~vector();
     constexpr vector& operator=(const vector& x);
+    constexpr vector& operator=(vector&& x)
+      noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+               allocator_traits<Allocator>::is_always_equal::value);
     constexpr vector& operator=(initializer_list<bool>);
     template<class InputIterator>
       constexpr void assign(InputIterator first, InputIterator last);
+    template<container-compatible-range<bool> R>
+      constexpr void assign_range(R&& rg);
     constexpr void assign(size_type n, const bool& t);
     constexpr void assign(initializer_list<bool>);
     constexpr allocator_type get_allocator() const noexcept;
     // iterators
     constexpr const_reference back() const;
     // modifiers
     template<class... Args> constexpr reference emplace_back(Args&&... args);
     constexpr void push_back(const bool& x);
+    template<container-compatible-range<bool> R>
+      constexpr void append_range(R&& rg);
     constexpr void pop_back();
     template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);
     constexpr iterator insert(const_iterator position, const bool& x);
     constexpr iterator insert(const_iterator position, size_type n, const bool& x);
     template<class InputIterator>
       constexpr iterator insert(const_iterator position,
                                 InputIterator first, InputIterator last);
+    template<container-compatible-range<bool> R>
+      constexpr iterator insert_range(const_iterator position, R&& rg);
     constexpr iterator insert(const_iterator position, initializer_list<bool> il);
     constexpr iterator erase(const_iterator position);
     constexpr iterator erase(const_iterator first, const_iterator last);
+    constexpr void swap(vector&)
+      noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
+               allocator_traits<Allocator>::is_always_equal::value);
+    static constexpr void swap(reference x, reference y) noexcept;
     constexpr void flip() noexcept;     // flips all bits
     constexpr void clear() noexcept;
   };
 }
 ```
 `reference`
 is a class that simulates the behavior of references of a single bit in
 `vector<bool>`. The conversion function returns `true` when the bit is
+set, and `false` otherwise. The assignment operators set the bit when
+the argument is (convertible to) `true` and clear it otherwise. `flip`
 reverses the state of the bit.
 ``` cpp
 constexpr void flip() noexcept;
 ```
 *Effects:* Replaces each element in the container with its complement.
 ``` cpp
+static constexpr void swap(reference x, reference y) noexcept;
 ```
 *Effects:* Exchanges the contents of `x` and `y` as if by:
 ``` cpp
 template<class Allocator> struct hash<vector<bool, Allocator>>;
 ```
 The specialization is enabled [[unord.hash]].
+``` cpp
+template<class T>
+  constexpr bool is-vector-bool-reference = see below;
+```
+The expression *`is-vector-bool-reference`*`<T>` is `true` if `T`
+denotes the type `vector<bool, Alloc>::reference` for some type `Alloc`
+and `vector<bool, Alloc>` is not a program-defined specialization.
+#### Formatter specialization for `vector<bool>` <a id="vector.bool.fmt">[[vector.bool.fmt]]</a>
+``` cpp
+namespace std {
+  template<class T, class charT>
+    requires is-vector-bool-reference<T>
+  struct formatter<T, charT> {
+  private:
+    formatter<bool, charT> underlying_;       // exposition only
+  public:
+    template<class ParseContext>
+      constexpr typename ParseContext::iterator
+        parse(ParseContext& ctx);
+    template<class FormatContext>
+      typename FormatContext::iterator
+        format(const T& ref, FormatContext& ctx) const;
+  };
+}
+```
+``` cpp
+template<class ParseContext>
+  constexpr typename ParseContext::iterator
+    parse(ParseContext& ctx);
+```
+Equivalent to: `return `*`underlying_`*`.parse(ctx);`
+``` cpp
+template<class FormatContext>
+  typename FormatContext::iterator
+    format(const T& ref, FormatContext& ctx) const;
+```
+Equivalent to: `return `*`underlying_`*`.format(ref, ctx);`

Diff to HTML by rtfpessoa