[sequences] - C++14 → C++17

Files changed (1) hide show

tmp/tmp60kp38mx/{from.md → to.md} +428 -356

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

@@ -1,23 +1,20 @@
 ## Sequence containers <a id="sequences">[[sequences]]</a>
 ### In general <a id="sequences.general">[[sequences.general]]</a>
 The headers `<array>`, `<deque>`, `<forward_list>`, `<list>`, and
-`<vector>` define template classes that meet the requirements for
 sequence containers.
-The headers `<queue>` and `<stack>` define container adaptors (
-[[container.adaptors]]) that also meet the requirements for sequence
-containers.
-\synopsis{Header \texttt{\<array\>} synopsis}
 ``` cpp
 #include <initializer_list>
 namespace std {
   template <class T, size_t N> struct array;
   template <class T, size_t N>
     bool operator==(const array<T, N>& x, const array<T, N>& y);
   template <class T, size_t N>
     bool operator!=(const array<T, N>& x, const array<T, N>& y);
@@ -42,19 +39,22 @@ namespace std {
     constexpr T& get(array<T, N>&) noexcept;
   template <size_t I, class T, size_t N>
     constexpr T&& get(array<T, N>&&) noexcept;
   template <size_t I, class T, size_t N>
     constexpr const T& get(const array<T, N>&) noexcept;
 }
 ```
-\synopsis{Header \texttt{\<deque\>} synopsis}
 ``` cpp
 #include <initializer_list>
 namespace std {
   template <class T, class Allocator = allocator<T>> class deque;
   template <class T, class Allocator>
     bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const deque<T, Allocator>& x, const deque<T, Allocator>& y);
@@ -65,20 +65,27 @@ namespace std {
   template <class T, class Allocator>
     bool operator>=(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template <class T, class Allocator>
-    void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
 }
 ```
-\synopsis{Header \texttt{\<forward_list\>} synopsis}
 ``` cpp
 #include <initializer_list>
 namespace std {
   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>
     bool operator< (const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
@@ -89,20 +96,27 @@ namespace std {
   template <class T, class Allocator>
     bool operator>=(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
   template <class T, class Allocator>
-    void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y);
 }
 ```
-\synopsis{Header \texttt{\<list\>} synopsis}
 ``` cpp
 #include <initializer_list>
 namespace std {
   template <class T, class Allocator = allocator<T>> class list;
   template <class T, class Allocator>
     bool operator==(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const list<T, Allocator>& x, const list<T, Allocator>& y);
@@ -113,20 +127,27 @@ namespace std {
   template <class T, class Allocator>
     bool operator>=(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
-    void swap(list<T,Allocator>& x, list<T,Allocator>& y);
 }
 ```
-\synopsis{Header \texttt{\<vector\>} synopsis}
 ``` cpp
 #include <initializer_list>
 namespace std {
   template <class T, class Allocator = allocator<T>> class vector;
   template <class T, class Allocator>
     bool operator==(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const vector<T, Allocator>& x, const vector<T, Allocator>& y);
@@ -137,40 +158,39 @@ namespace std {
   template <class T, class Allocator>
     bool operator>=(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
-    void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
   template <class Allocator> class vector<bool, Allocator>;
   // hash support
   template <class T> struct hash;
   template <class Allocator> struct hash<vector<bool, Allocator>>;
 }
 ```
 ### Class template `array` <a id="array">[[array]]</a>
 #### Class template `array` overview <a id="array.overview">[[array.overview]]</a>
 The header `<array>` defines a class template for storing fixed-size
-sequences of objects. An `array` supports random access iterators. An
-instance of `array<T, N>` stores `N` elements of type `T`, so that
-`size() == N` is an invariant. The elements of an `array` are stored
-contiguously, meaning that if `a` is an `array<T, N>` then it obeys the
-identity `&a[n] == &a[0] + n` for all `0 <= n < N`.
-An `array` is an aggregate ([[dcl.init.aggr]]) that can be initialized
-with the syntax
-``` cpp
-array<T, N> a = { initializer-list };
-```
-where *initializer-list* is a comma-separated list of up to `N` elements
-whose types are convertible to `T`.
 An `array` satisfies 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` satisfies some of the requirements
@@ -182,70 +202,67 @@ semantic information.
 ``` cpp
 namespace std {
   template <class T, size_t N>
   struct array {
     //  types:
- typedef T&                                    reference;
- typedef const T&                              const_reference;
- typedef implementation-defined  // type of array::iterator                iterator;
- typedef implementation-defined  // type of array::const_iterator                const_iterator;
- typedef size_t                                size_type;
- typedef ptrdiff_t                             difference_type;
- typedef T                                     value_type;
- typedef T*                                    pointer;
- typedef const T*                              const_pointer;
- typedef std::reverse_iterator<iterator>       reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-    T       elems[N];           // exposition only
     // no explicit construct/copy/destroy for aggregate type
     void fill(const T& u);
-    void swap(array&) noexcept(noexcept(swap(declval<T&>(), declval<T&>())));
     // iterators:
-    iterator               begin() noexcept;
-    const_iterator         begin() const noexcept;
-    iterator               end() noexcept;
-    const_iterator         end() const noexcept;
-    reverse_iterator       rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator       rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
-    const_iterator         cbegin() const noexcept;
-    const_iterator         cend() const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
     // capacity:
     constexpr size_type size() const noexcept;
     constexpr size_type max_size() const noexcept;
-    constexpr bool      empty() const noexcept;
     // element access:
-    reference operator[](size_type n);
     constexpr const_reference operator[](size_type n) const;
-    reference at(size_type n);
     constexpr const_reference at(size_type n) const;
-    reference front();
     constexpr const_reference front() const;
-    reference back();
     constexpr const_reference back() const;
-    T *       data() noexcept;
-    const T * data() const noexcept;
   };
 }
 ```
-The member variable `elems` is shown for exposition only, to emphasize
-that `array` is a class aggregate. The name `elems` is not part of
-`array`’s interface.
 #### `array` 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.ctor]], [[class.dtor]], and [[class.copy]]) to conform to the
@@ -253,63 +270,70 @@ 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 `MoveConstructible` or `MoveAssignable`,
 respectively.
 #### `array` specialized algorithms <a id="array.special">[[array.special]]</a>
 ``` cpp
-template <class T, size_t N> void swap(array<T,N>& x, array<T,N>& y) noexcept(noexcept(x.swap(y)));
 ```
-*Effects:*
-``` cpp
-x.swap(y);
-```
 *Complexity:* Linear in `N`.
 #### `array::size` <a id="array.size">[[array.size]]</a>
 ``` cpp
 template <class T, size_t N> constexpr size_type array<T, N>::size() const noexcept;
 ```
-*Returns:* `N`
 #### `array::data` <a id="array.data">[[array.data]]</a>
 ``` cpp
-T* data() noexcept;
-const T* data() const noexcept;
 ```
-*Returns:* `elems`.
 #### `array::fill` <a id="array.fill">[[array.fill]]</a>
 ``` cpp
 void fill(const T& u);
 ```
-*Effects:* `fill_n(begin(), N, u)`
 #### `array::swap` <a id="array.swap">[[array.swap]]</a>
 ``` cpp
-void swap(array& y) noexcept(noexcept(swap(declval<T&>(), declval<T&>())));
 ```
-*Effects:* `swap_ranges(begin(), end(), y.begin())`
-*Throws:* Nothing unless one of the element-wise swap calls throws an
-exception.
-*Note:* 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.
 #### Zero sized arrays <a id="array.zero">[[array.zero]]</a>
 `array` shall provide support for the special case `N == 0`.
@@ -317,19 +341,18 @@ In the case that `N == 0`, `begin() == end() ==` unique value. The
 return value of `data()` is unspecified.
 The effect of calling `front()` or `back()` for a zero-sized array is
 undefined.
-Member function `swap()` shall have a *noexcept-specification* which is
-equivalent to `noexcept(true)`.
 #### Tuple interface to class template `array` <a id="array.tuple">[[array.tuple]]</a>
 ``` cpp
 template <class T, size_t N>
-struct tuple_size<array<T, N>>
-  : integral_constant<size_t, N> { };
 ```
 ``` cpp
 tuple_element<I, array<T, N>>::type
 ```
@@ -339,44 +362,33 @@ tuple_element<I, array<T, N> >::type
 *Value:* The type T.
 ``` cpp
 template <size_t I, class T, size_t N>
   constexpr T& get(array<T, N>& a) noexcept;
-```
-*Requires:* `I < N`. The program is ill-formed if `I` is out of bounds.
-*Returns:* A reference to the `I`th element of `a`, where indexing is
-zero-based.
-``` cpp
 template <size_t I, class T, size_t N>
   constexpr T&& get(array<T, N>&& a) noexcept;
-```
-*Effects:* Equivalent to `return std::move(get<I>(a));`
-``` cpp
 template <size_t I, class T, size_t N>
   constexpr const T& get(const array<T, N>& a) noexcept;
 ```
 *Requires:* `I < N`. The program is ill-formed if `I` is out of bounds.
-*Returns:* A const reference to the `I`th element of `a`, where indexing
-is zero-based.
 ### Class template `deque` <a id="deque">[[deque]]</a>
 #### Class template `deque` overview <a id="deque.overview">[[deque.overview]]</a>
-A `deque` is a sequence container that, like a `vector` ([[vector]]),
-supports random access iterators. In addition, it supports constant time
 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. As
-with vectors, storage management is handled automatically.
 A `deque` satisfies 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
@@ -389,24 +401,24 @@ information.
 namespace std {
   template <class T, class Allocator = allocator<T>>
   class deque {
   public:
     // types:
- typedef value_type&                           reference;
- typedef const value_type&                     const_reference;
- typedef implementation-defined iterator;       // See [container.requirements]
- typedef implementation-defined                const_iterator; // See [container.requirements]
- typedef implementation-defined                size_type;      // See [container.requirements]
- typedef implementation-defined                difference_type;// See [container.requirements]
- typedef T                                     value_type;
- typedef Allocator                             allocator_type;
- typedef typename allocator_traits<Allocator>::pointer           pointer;
- typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
- typedef std::reverse_iterator<iterator>       reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-    // [deque.cons], construct/copy/destroy:
     deque() : deque(Allocator()) { }
     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>
@@ -417,11 +429,12 @@ namespace std {
     deque(deque&&, const Allocator&);
     deque(initializer_list<T>, const Allocator& = Allocator());
     ~deque();
     deque& operator=(const deque& x);
-    deque& operator=(deque&& x);
     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>);
@@ -440,17 +453,17 @@ namespace std {
     const_iterator         cbegin() const noexcept;
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
-    // [deque.capacity], capacity:
     size_type size() const noexcept;
     size_type max_size() const noexcept;
     void      resize(size_type sz);
     void      resize(size_type sz, const T& c);
     void      shrink_to_fit();
-    bool      empty() const noexcept;
     // element access:
     reference       operator[](size_type n);
     const_reference operator[](size_type n) const;
     reference       at(size_type n);
@@ -458,13 +471,13 @@ namespace std {
     reference       front();
     const_reference front() const;
     reference       back();
     const_reference back() const;
-    // [deque.modifiers], modifiers:
-    template <class... Args> void emplace_front(Args&&... args);
-    template <class... Args> void 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);
@@ -480,14 +493,20 @@ namespace std {
     void pop_front();
     void pop_back();
     iterator erase(const_iterator position);
     iterator erase(const_iterator first, const_iterator last);
-    void     swap(deque&);
     void     clear() noexcept;
   };
   template <class T, class Allocator>
     bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template <class T, class Allocator>
@@ -497,13 +516,14 @@ namespace std {
   template <class T, class Allocator>
     bool operator>=(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
-  // specialized algorithms:
   template <class T, class Allocator>
-    void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
 }
 ```
 #### `deque` constructors, copy, and assignment <a id="deque.cons">[[deque.cons]]</a>
@@ -525,12 +545,11 @@ the specified allocator.
 *Requires:* `T` shall be `DefaultInsertable` 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.
@@ -538,12 +557,11 @@ 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.
@@ -553,38 +571,47 @@ using the specified allocator.
 ``` cpp
 void resize(size_type sz);
 ```
-*Effects:* If `sz <= size()`, equivalent to calling `pop_back()`
-`size() - sz` times. If `size() < sz`, appends `sz - size()`
-default-inserted elements to the sequence.
 *Requires:* `T` shall be `MoveInsertable` and `DefaultInsertable` into
 `*this`.
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
-*Effects:* If `sz <= size()`, equivalent to calling `pop_back()`
-`size() - sz` times. If `size() < sz`, appends `sz - size()` copies of
-`c` to the sequence.
 *Requires:* `T` shall be `CopyInsertable` into `*this`.
 ``` cpp
 void shrink_to_fit();
 ```
 *Requires:* `T` shall be `MoveInsertable` into `*this`.
 *Complexity:* Linear in the size of the sequence.
-*Remarks:* `shrink_to_fit` is a non-binding request to reduce memory use
-but does not change the size of the sequence. The request is non-binding
-to allow latitude for implementation-specific optimizations.
 #### `deque` modifiers <a id="deque.modifiers">[[deque.modifiers]]</a>
 ``` cpp
 iterator insert(const_iterator position, const T& x);
@@ -593,12 +620,12 @@ 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> void emplace_front(Args&&... args);
-template <class... Args> void 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);
@@ -623,54 +650,58 @@ 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);
 ```
 *Effects:* An erase operation that erases the last element of a deque
 invalidates only the past-the-end iterator and all iterators and
 references to the erased elements. An erase operation that erases the
-first element of a deque but not the last element invalidates only the
-erased elements. An erase operation that erases neither the first
-element nor the last element of a deque invalidates the past-the-end
-iterator and all iterators and references to all the elements of the
-deque.
-*Complexity:* The number of calls to the destructor is the same as the
-number of elements erased, but the number of calls to the assignment
-operator 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 copy constructor,
 move constructor, assignment operator, or move assignment operator of
 `T`.
 #### `deque` specialized algorithms <a id="deque.special">[[deque.special]]</a>
 ``` cpp
 template <class T, class Allocator>
-  void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
 ```
-*Effects:*
-``` cpp
-x.swap(y);
-```
 ### Class template `forward_list` <a id="forwardlist">[[forwardlist]]</a>
 #### Class template `forward_list` overview <a id="forwardlist.overview">[[forwardlist.overview]]</a>
 A `forward_list` is a container that supports forward iterators and
 allows constant time insert and erase operations anywhere within the
 sequence, with storage management handled automatically. Fast random
-access to list elements is not supported. 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.
 A `forward_list` satisfies all of the requirements of a container
 (Table  [[tab:containers.container.requirements]]), except that the
 `size()` member function is not provided and `operator==` has linear
 complexity. A `forward_list` also satisfies all of the requirements for
@@ -680,34 +711,34 @@ In addition, a `forward_list` provides the `assign` member functions
 optional container requirements (Table
 [[tab:containers.sequence.optional]]). Descriptions are provided here
 only for operations on `forward_list` that are not described in that
 table or for operations where there is additional semantic information.
-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.
 ``` cpp
 namespace std {
   template <class T, class Allocator = allocator<T>>
   class forward_list {
   public:
     // types:
- typedef value_type&                                           reference;
- typedef const value_type&                                     const_reference;
- typedef implementation-defined iterator;       // See [container.requirements]
- typedef implementation-defined const_iterator; // See [container.requirements]
- typedef implementation-defined size_type;      // See [container.requirements]
- typedef implementation-defined difference_type;// See [container.requirements]
- typedef T value_type;
- typedef Allocator allocator_type;
- typedef typename allocator_traits<Allocator>::pointer         pointer;
- typedef typename allocator_traits<Allocator>::const_pointer   const_pointer;
-    // [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());
@@ -719,19 +750,20 @@ namespace std {
     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);
     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;
@@ -743,16 +775,16 @@ namespace std {
     // capacity:
     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> void 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);
@@ -764,17 +796,18 @@ namespace std {
       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&);
     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,
@@ -799,11 +832,15 @@ namespace std {
     template <class Compare> void sort(Compare comp);
     void reverse() noexcept;
   };
- // Comparison operators
   template <class T, class Allocator>
     bool operator==(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
   template <class T, class Allocator>
@@ -813,16 +850,23 @@ namespace std {
   template <class T, class Allocator>
     bool operator>=(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
-  // [forwardlist.spec], specialized algorithms:
   template <class T, class Allocator>
-    void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y);
 }
 ```
 #### `forward_list` constructors, copy, assignment <a id="forwardlist.cons">[[forwardlist.cons]]</a>
 ``` cpp
 explicit forward_list(const Allocator&);
 ```
@@ -899,11 +943,11 @@ elements into a `forward_list` is linear in `n`, and the number of calls
 to the copy or move constructor of `T` is exactly equal to `n`. Erasing
 `n` elements from a `forward_list` is linear in `n` and the number of
 calls to the destructor of type `T` is exactly equal to `n`.
 ``` cpp
-template <class... Args> void emplace_front(Args&&... args);
 ```
 *Effects:* Inserts an object of type `value_type` constructed with
 `value_type(std::forward<Args>(args)...)` at the beginning of the list.
@@ -916,11 +960,11 @@ void push_front(T&& x);
 ``` cpp
 void pop_front();
 ```
-*Effects:* `erase_after(before_begin())`
 ``` cpp
 iterator insert_after(const_iterator position, const T& x);
 iterator insert_after(const_iterator position, T&& x);
 ```
@@ -1023,14 +1067,12 @@ end of the list.
 void resize(size_type sz, const value_type& c);
 ```
 *Effects:* If `sz < distance(begin(), end())`, erases the last
 `distance(begin(), end()) - sz` elements from the list. Otherwise,
-inserts `sz - distance(begin(), end())` elements at the end of the list
-such that each new element, `e`, is initialized by a method equivalent
-to calling
-`allocator_traits<allocator_type>::construct(get_allocator(), std::addressof(e), c)`.
 *Requires:* `T` shall be `CopyInsertable` into `*this`.
 ``` cpp
 void clear() noexcept;
@@ -1057,11 +1099,11 @@ those same elements but as members of `*this`. Iterators referring to
 the moved elements will continue to refer to their elements, but they
 now behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
-*Complexity:* 𝑂(distance(x.begin(), x.end()))
 ``` cpp
 void splice_after(const_iterator position, forward_list& x, const_iterator i);
 void splice_after(const_iterator position, forward_list&& x, const_iterator i);
 ```
@@ -1100,20 +1142,20 @@ dereferenceable. `position` is not an iterator in the range (`first`,
 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:* 𝑂(distance(first, last))
 ``` cpp
 void remove(const T& value);
 template <class Predicate> void remove_if(Predicate pred);
 ```
 *Effects:* Erases all the elements in the list referred by a list
 iterator `i` for which the following conditions hold: `*i == value` (for
-`remove()`), `pred(*i)` is true (for `remove_if()`). Invalidates only
 the iterators and references to the erased elements.
 *Throws:* Nothing unless an exception is thrown by the equality
 comparison or the predicate.
@@ -1159,11 +1201,11 @@ references to the moved elements of `x` now refer to those same elements
 but as members of `*this`. Iterators referring to the moved elements
 will continue to refer to their elements, but they now behave as
 iterators into `*this`, not into `x`.
 *Remarks:* Stable ([[algorithm.stable]]). The behavior is undefined if
-`this->get_allocator() != x.get_allocator()`.
 *Complexity:* At most
 `distance(begin(), end()) + distance(x.begin(), x.end()) - 1`
 comparisons.
@@ -1175,11 +1217,11 @@ template <class Compare> void sort(Compare comp);
 *Requires:* `operator<` (for the version with no arguments) or `comp`
 (for the version with a comparison argument) defines a strict weak
 ordering ([[alg.sorting]]).
 *Effects:* Sorts the list according to the `operator<` or the `comp`
-function object. If an exception is thrown the order of the elements in
 `*this` is unspecified. Does not affect the validity of iterators and
 references.
 *Remarks:* Stable ([[algorithm.stable]]).
@@ -1197,14 +1239,15 @@ affect the validity of iterators and references.
 #### `forward_list` specialized algorithms <a id="forwardlist.spec">[[forwardlist.spec]]</a>
 ``` cpp
 template <class T, class Allocator>
-  void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y);
 ```
-*Effects:* `x.swap(y)`
 ### Class template `list` <a id="list">[[list]]</a>
 #### Class template `list` overview <a id="list.overview">[[list.overview]]</a>
@@ -1230,24 +1273,24 @@ information.
 namespace std {
   template <class T, class Allocator = allocator<T>>
   class list {
   public:
     // types:
- typedef value_type&                                             reference;
- typedef const value_type&                                       const_reference;
- typedef implementation-defined iterator;       // see [container.requirements]
- typedef implementation-defined                const_iterator; // see [container.requirements]
- typedef implementation-defined                size_type;      // see [container.requirements]
- typedef implementation-defined                difference_type;// see [container.requirements]
- typedef T                                     value_type;
- typedef Allocator                             allocator_type;
- typedef typename allocator_traits<Allocator>::pointer           pointer;
- typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
- typedef std::reverse_iterator<iterator>       reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-    // [list.cons], construct/copy/destroy:
     list() : list(Allocator()) { }
     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>
@@ -1257,11 +1300,12 @@ namespace std {
     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);
     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>);
@@ -1280,11 +1324,11 @@ namespace std {
     const_iterator         cbegin() const noexcept;
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
-    // [list.capacity], capacity:
     bool      empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
     void      resize(size_type sz);
     void      resize(size_type sz, const T& c);
@@ -1293,16 +1337,16 @@ namespace std {
     reference       front();
     const_reference front() const;
     reference       back();
     const_reference back() const;
-    // [list.modifiers], modifiers:
-    template <class... Args> void emplace_front(Args&&... args);
- void pop_front();
-    template <class... Args> void emplace_back(Args&&... args);
     void push_front(const T& x);
     void push_front(T&& x);
     void push_back(const T& x);
     void push_back(T&& x);
     void pop_back();
     template <class... Args> iterator emplace(const_iterator position, Args&&... args);
@@ -1314,14 +1358,15 @@ namespace std {
                       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&);
     void     clear() noexcept;
-    // [list.ops], list operations:
     void splice(const_iterator position, list& x);
     void splice(const_iterator position, list&& x);
     void splice(const_iterator position, list& x, const_iterator i);
     void splice(const_iterator position, list&& x, const_iterator i);
     void splice(const_iterator position, list& x,
@@ -1345,10 +1390,15 @@ namespace std {
     template <class Compare> void sort(Compare comp);
     void reverse() noexcept;
   };
   template <class T, class Allocator>
     bool operator==(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
@@ -1358,16 +1408,22 @@ namespace std {
   template <class T, class Allocator>
     bool operator>=(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const list<T, Allocator>& x, const list<T, Allocator>& y);
-  // specialized algorithms:
   template <class T, class Allocator>
-    void swap(list<T,Allocator>& x, list<T,Allocator>& y);
 }
 ```
 #### `list` constructors, copy, and assignment <a id="list.cons">[[list.cons]]</a>
 ``` cpp
 explicit list(const Allocator&);
 ```
@@ -1386,12 +1442,11 @@ the specified allocator.
 *Requires:* `T` shall be `DefaultInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
-list(size_type n, const T& value,
-     const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `list` with `n` copies of `value`, using the
 specified allocator.
@@ -1399,12 +1454,11 @@ specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 template <class InputIterator>
-list(InputIterator first, InputIterator last,
-     const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `list` equal to the range \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
@@ -1414,11 +1468,11 @@ list(InputIterator first, InputIterator last,
 ``` cpp
 void resize(size_type sz);
 ```
 *Effects:* If `size() < sz`, appends `sz - size()` default-inserted
-elements to the sequence. If `sz <= size()`, equivalent to
 ``` cpp
 list<T>::iterator it = begin();
 advance(it, sz);
 erase(it, end());
@@ -1428,11 +1482,11 @@ erase(it, end());
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
-*Effects:*
 ``` cpp
 if (sz > size())
   insert(end(), sz-size(), c);
 else if (sz < size()) {
@@ -1455,12 +1509,12 @@ 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> void emplace_front(Args&&... args);
-template <class... Args> void 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);
@@ -1524,19 +1578,19 @@ now behave as iterators into `*this`, not into `x`.
 ``` cpp
 void splice(const_iterator position, list& x, const_iterator i);
 void splice(const_iterator position, list&& x, const_iterator i);
 ```
 *Effects:* Inserts an element pointed to by `i` from list `x` before
 `position` and removes the element from `x`. The result is unchanged if
 `position == i` or `position == ++i`. Pointers and references to `*i`
 continue to refer to this same element but as a member of `*this`.
 Iterators to `*i` (including `i` itself) continue to refer to the same
 element, but now behave as iterators into `*this`, not into `x`.
-*Requires:* `i` is a valid dereferenceable iterator of `x`.
 *Throws:* Nothing.
 *Complexity:* Constant time.
 ``` cpp
@@ -1544,19 +1598,20 @@ void splice(const_iterator position, list& x, const_iterator first,
             const_iterator last);
 void splice(const_iterator position, list&& x, const_iterator first,
             const_iterator last);
 ```
 *Effects:* Inserts elements in the range \[`first`, `last`) before
-`position` and removes the elements from `x`.
-*Requires:* `[first, last)` is a valid range in `x`. The result is
-undefined if `position` is an iterator in the range \[`first`, `last`).
-Pointers and references to the moved elements of `x` now refer to those
-same elements but as members of `*this`. Iterators referring to the
-moved elements will continue to refer to their elements, but they now
-behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* Constant time if `&x == this`; otherwise, linear time.
@@ -1611,20 +1666,20 @@ shall be sorted according to this ordering.
 *Effects:* If `(&x == this)` does nothing; otherwise, merges the two
 sorted ranges `[begin(), end())` and `[x.begin(), x.end())`. The result
 is a range in which the elements will be sorted in non-decreasing order
 according to the ordering defined by `comp`; that is, for every iterator
 `i`, in the range other than the first, the condition
-`comp(*i, *(i - 1))` will be false. Pointers and references to the moved
-elements of `x` now refer to those same elements but as members of
 `*this`. Iterators referring to the moved elements will continue to
 refer to their elements, but they now behave as iterators into `*this`,
 not into `x`.
 *Remarks:* Stable ([[algorithm.stable]]). If `(&x != this)` the range
 `[x.begin(), x.end())` is empty after the merge. No elements are copied
 by this operation. The behavior is undefined if
-`this->get_allocator() != x.get_allocator()`.
 *Complexity:* At most `size() + x.size() - 1` applications of `comp` if
 `(&x != this)`; otherwise, no applications of `comp` are performed. If
 an exception is thrown other than by a comparison there are no effects.
@@ -1644,89 +1699,85 @@ template <class Compare> void sort(Compare comp);
 *Requires:* `operator<` (for the first version) or `comp` (for the
 second version) shall define a strict weak ordering ([[alg.sorting]]).
 *Effects:* Sorts the list according to the `operator<` or a `Compare`
-function object. Does not affect the validity of iterators and
 references.
 *Remarks:* Stable ([[algorithm.stable]]).
-*Complexity:* Approximately N log(N) comparisons, where `N == size()`.
 #### `list` specialized algorithms <a id="list.special">[[list.special]]</a>
 ``` cpp
 template <class T, class Allocator>
-  void swap(list<T,Allocator>& x, list<T,Allocator>& y);
 ```
-*Effects:*
-``` cpp
-x.swap(y);
-```
 ### Class template `vector` <a id="vector">[[vector]]</a>
 #### Class template `vector` overview <a id="vector.overview">[[vector.overview]]</a>
-A `vector` is a sequence container that supports random access
-iterators. In addition, it 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. The elements of a vector are stored
-contiguously, meaning that if `v` is a `vector<T, Allocator>` where `T`
-is some type other than `bool`, then it obeys the identity
-`&v[n] == &v[0] + n` for all `0 <= n < v.size()`.
 A `vector` satisfies 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]]), and
-of an allocator-aware container (Table
-[[tab:containers.allocatoraware]]). 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.
 ``` cpp
 namespace std {
   template <class T, class Allocator = allocator<T>>
   class vector {
   public:
     // types:
- typedef value_type&                           reference;
- typedef const value_type&                     const_reference;
- typedef implementation-defined iterator;       // see [container.requirements]
- typedef implementation-defined                const_iterator; // see [container.requirements]
- typedef implementation-defined                size_type;      // see [container.requirements]
- typedef implementation-defined                difference_type;// see [container.requirements]
- typedef T                                     value_type;
- typedef Allocator                             allocator_type;
- typedef typename allocator_traits<Allocator>::pointer           pointer;
- typedef typename allocator_traits<Allocator>::const_pointer     const_pointer;
- typedef std::reverse_iterator<iterator>       reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-    // [vector.cons], construct/copy/destroy:
-    vector() : vector(Allocator()) { }
-    explicit vector(const Allocator&);
     explicit vector(size_type n, const Allocator& = Allocator());
     vector(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
-      vector(InputIterator first, InputIterator last,
-             const Allocator& = Allocator());
     vector(const vector& x);
-    vector(vector&&);
     vector(const vector&, const Allocator&);
     vector(vector&&, const Allocator&);
     vector(initializer_list<T>, const Allocator& = Allocator());
     ~vector();
     vector& operator=(const vector& x);
-    vector& operator=(vector&& x);
     vector& operator=(initializer_list<T>);
     template <class InputIterator>
       void assign(InputIterator first, InputIterator last);
     void assign(size_type n, const T& u);
     void assign(initializer_list<T>);
@@ -1745,17 +1796,17 @@ namespace std {
     const_iterator         cbegin() const noexcept;
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
-    // [vector.capacity], capacity:
     size_type size() const noexcept;
     size_type max_size() const noexcept;
     void      resize(size_type sz);
     void      resize(size_type sz, const T& c);
-    size_type capacity() const noexcept;
-    bool      empty() const noexcept;
     void      reserve(size_type n);
     void      shrink_to_fit();
     // element access:
     reference       operator[](size_type n);
@@ -1769,30 +1820,36 @@ namespace std {
     // [vector.data], data access
     T*       data() noexcept;
     const T* data() const noexcept;
-    // [vector.modifiers], modifiers:
-    template <class... Args> void emplace_back(Args&&... args);
     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 first, const_iterator last);
-    void     swap(vector&);
     void     clear() noexcept;
   };
   template <class T, class Allocator>
     bool operator==(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
@@ -1802,16 +1859,22 @@ namespace std {
   template <class T, class Allocator>
     bool operator>=(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
-  // [vector.special], specialized algorithms:
   template <class T, class Allocator>
-    void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
 }
 ```
 #### `vector` constructors, copy, and assignment <a id="vector.cons">[[vector.cons]]</a>
 ``` cpp
 explicit vector(const Allocator&);
 ```
@@ -1852,13 +1915,13 @@ template <class InputIterator>
 *Effects:* Constructs a `vector` equal to the range \[`first`, `last`),
 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.
 #### `vector` capacity <a id="vector.capacity">[[vector.capacity]]</a>
 ``` cpp
 size_type capacity() const noexcept;
@@ -1897,20 +1960,30 @@ vector greater than the value of `capacity()`.
 void shrink_to_fit();
 ```
 *Requires:* `T` shall be `MoveInsertable` into `*this`.
 *Complexity:* Linear in the size of the sequence.
-*Remarks:* `shrink_to_fit` is a non-binding request to reduce
-`capacity()` to `size()`. The request is non-binding to allow latitude
-for implementation-specific optimizations. If an exception is thrown
-other than by the move constructor of a non-`CopyInsertable` `T` there
-are no effects.
 ``` cpp
-void swap(vector& x);
 ```
 *Effects:* Exchanges the contents and `capacity()` of `*this` with that
 of `x`.
@@ -1918,13 +1991,13 @@ of `x`.
 ``` cpp
 void resize(size_type sz);
 ```
-*Effects:* If `sz <= size()`, equivalent to calling `pop_back()`
-`size() - sz` times. If `size() < sz`, appends `sz - size()`
-default-inserted elements to the sequence.
 *Requires:* `T` shall be `MoveInsertable` and `DefaultInsertable` into
 `*this`.
 *Remarks:* If an exception is thrown other than by the move constructor
@@ -1932,13 +2005,13 @@ of a non-`CopyInsertable` `T` there are no effects.
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
-*Effects:* If `sz <= size()`, equivalent to calling `pop_back()`
-`size() - sz` times. If `size() < sz`, appends `sz - size()` copies of
-`c` to the sequence.
 *Requires:* `T` shall be `CopyInsertable` into `*this`.
 *Remarks:* If an exception is thrown there are no effects.
@@ -1948,11 +2021,11 @@ void resize(size_type sz, const T& c);
 T*         data() noexcept;
 const T*   data() const noexcept;
 ```
 *Returns:* A pointer such that \[`data()`, `data() + size()`) is a valid
-range. For a non-empty vector, `data()` `==` `&front()`.
 *Complexity:* Constant time.
 #### `vector` modifiers <a id="vector.modifiers">[[vector.modifiers]]</a>
@@ -1962,81 +2035,81 @@ 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> void emplace_back(Args&&... args);
 template <class... Args> iterator emplace(const_iterator position, Args&&... args);
 void push_back(const T& x);
 void push_back(T&& x);
 ```
 *Remarks:* Causes reallocation if the new size is greater than the old
-capacity. If no reallocation happens, all the iterators and references
-before the insertion point remain valid. If an exception is thrown other
-than by the copy constructor, move constructor, assignment operator, or
-move assignment operator of `T` or by any `InputIterator` operation
-there are no effects. If an exception is thrown while inserting a single
-element at the end and `T` is `CopyInsertable` or
-`is_nothrow_move_constructible<T>::value` is `true`, there are no
-effects. Otherwise, if an exception is thrown by the move constructor of
-a non-`CopyInsertable` `T`, the effects are unspecified.
 *Complexity:* The complexity is linear in the number of elements
 inserted plus the distance to the end of the vector.
 ``` cpp
 iterator erase(const_iterator position);
 iterator erase(const_iterator first, const_iterator last);
 ```
 *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 move 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 copy constructor,
-move constructor, assignment operator, or move assignment operator of
-`T`.
 #### `vector` specialized algorithms <a id="vector.special">[[vector.special]]</a>
 ``` cpp
 template <class T, class Allocator>
-  void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
 ```
-*Effects:*
-``` cpp
-x.swap(y);
-```
 ### 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:
- typedef bool                                  const_reference;
- typedef implementation-defined                iterator;       // see [container.requirements]
- typedef implementation-defined                const_iterator; // see [container.requirements]
- typedef implementation-defined                size_type;      // see [container.requirements]
- typedef implementation-defined                difference_type;// see [container.requirements]
- typedef bool                                  value_type;
- typedef Allocator                             allocator_type;
- typedef implementation-defined                pointer;
- typedef implementation-defined                const_pointer;
- typedef std::reverse_iterator<iterator>       reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
     // bit reference:
     class reference {
       friend class vector;
       reference() noexcept;
@@ -2086,15 +2159,15 @@ namespace std {
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
     // capacity:
     size_type size() const noexcept;
     size_type max_size() const noexcept;
     void      resize(size_type sz, bool c = false);
-    size_type capacity() const noexcept;
-    bool      empty() const noexcept;
     void      reserve(size_type n);
     void      shrink_to_fit();
     // element access:
     reference       operator[](size_type n);
@@ -2105,11 +2178,11 @@ namespace std {
     const_reference front() const;
     reference       back();
     const_reference back() const;
     // modifiers:
-    template <class... Args> void emplace_back(Args&&... args);
     void push_back(const bool& x);
     void pop_back();
     template <class... Args> iterator emplace(const_iterator position, Args&&... args);
     iterator insert(const_iterator position, const bool& x);
     iterator insert(const_iterator position, size_type n, const bool& x);
@@ -2129,21 +2202,21 @@ namespace std {
 ```
 Unless described below, all operations have the same requirements and
 semantics as the primary `vector` template, except that operations
 dealing with the `bool` value type map to bit values in the container
-storage and allocator_traits::construct ([[allocator.traits.members]])
-is not used to construct these values.
 There is no requirement that the data be stored as a contiguous
 allocation of `bool` values. A space-optimized representation of bits is
 recommended instead.
 `reference`
 is a class that simulates the behavior of references of a single bit in
-`vector<bool>`. The conversion operator 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
@@ -2154,11 +2227,11 @@ void flip() noexcept;
 ``` cpp
 static void swap(reference x, reference y) noexcept;
 ```
-*Effects:* exchanges the contents of `x` and `y` as if by
 ``` cpp
 bool b = x;
 x = y;
 y = b;
@@ -2166,8 +2239,7 @@ y = b;
 ``` cpp
 template <class Allocator> struct hash<vector<bool, Allocator>>;
 ```
-The template specialization shall meet the requirements of class
-template `hash` ([[unord.hash]]).

 ## Sequence containers <a id="sequences">[[sequences]]</a>
 ### In general <a id="sequences.general">[[sequences.general]]</a>
 The headers `<array>`, `<deque>`, `<forward_list>`, `<list>`, and
+`<vector>` define class templates that meet the requirements for
 sequence containers.
+### Header `<array>` synopsis <a id="array.syn">[[array.syn]]</a>
 ``` cpp
 #include <initializer_list>
 namespace std {
+  // [array], class template array
   template <class T, size_t N> struct array;
   template <class T, size_t N>
     bool operator==(const array<T, N>& x, const array<T, N>& y);
   template <class T, size_t N>
     bool operator!=(const array<T, N>& x, const array<T, N>& y);
     constexpr T& get(array<T, N>&) noexcept;
   template <size_t I, class T, size_t N>
     constexpr T&& get(array<T, N>&&) noexcept;
   template <size_t I, class T, size_t N>
     constexpr const T& get(const array<T, N>&) noexcept;
+  template <size_t I, class T, size_t N>
+    constexpr const T&& get(const array<T, N>&&) noexcept;
 }
 ```
+### Header `<deque>` synopsis <a id="deque.syn">[[deque.syn]]</a>
 ``` cpp
 #include <initializer_list>
 namespace std {
+  // [deque], class template deque
   template <class T, class Allocator = allocator<T>> class deque;
   template <class T, class Allocator>
     bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator>=(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template <class T, class Allocator>
+    void swap(deque<T, Allocator>& x, deque<T, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  namespace pmr {
+    template <class T>
+      using deque = std::deque<T, polymorphic_allocator<T>>;
+  }
 }
 ```
+### Header `<forward_list>` synopsis <a id="forward_list.syn">[[forward_list.syn]]</a>
 ``` cpp
 #include <initializer_list>
 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>
     bool operator< (const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator>=(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
   template <class T, class Allocator>
+    void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  namespace pmr {
+    template <class T>
+      using forward_list = std::forward_list<T, polymorphic_allocator<T>>;
+  }
 }
 ```
+### Header `<list>` synopsis <a id="list.syn">[[list.syn]]</a>
 ``` cpp
 #include <initializer_list>
 namespace std {
+  // [list], class template list
   template <class T, class Allocator = allocator<T>> class list;
   template <class T, class Allocator>
     bool operator==(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator>=(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
+    void swap(list<T, Allocator>& x, list<T, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  namespace pmr {
+    template <class T>
+      using list = std::list<T, polymorphic_allocator<T>>;
+  }
 }
 ```
+### Header `<vector>` synopsis <a id="vector.syn">[[vector.syn]]</a>
 ``` cpp
 #include <initializer_list>
 namespace std {
+  // [vector], class template vector
   template <class T, class Allocator = allocator<T>> class vector;
   template <class T, class Allocator>
     bool operator==(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator>=(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
+    void swap(vector<T, Allocator>& x, vector<T, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  // [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>
 #### Class template `array` 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` satisfies 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` satisfies some of the requirements
 ``` cpp
 namespace std {
   template <class T, size_t N>
   struct array {
     //  types:
+ using value_type             = T;
+ using pointer                = T*;
+ using const_pointer          = const T*;
+ using reference              = T&;
+ using const_reference        = const T&;
+ using size_type              = size_t;
+ using difference_type        = ptrdiff_t;
+ using iterator               = implementation-defined  // type of array::iterator; // see [container.requirements]
+ using const_iterator         = implementation-defined  // type of array::const_iterator; // see [container.requirements]
+ using reverse_iterator       = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     // no explicit construct/copy/destroy for aggregate type
     void fill(const T& u);
+    void swap(array&) noexcept(is_nothrow_swappable_v<T>);
     // iterators:
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // capacity:
+    constexpr bool      empty() const noexcept;
     constexpr size_type size() const noexcept;
     constexpr size_type max_size() const noexcept;
     // element access:
+ constexpr reference operator[](size_type n);
     constexpr const_reference operator[](size_type n) const;
+ constexpr reference at(size_type n);
     constexpr const_reference at(size_type n) const;
+ constexpr reference front();
     constexpr const_reference front() const;
+ constexpr reference back();
     constexpr const_reference back() const;
+ constexpr T *       data() noexcept;
+ constexpr const T * data() const noexcept;
   };
+  template<class T, class... U>
+    array(T, U...) -> array<T, 1 + sizeof...(U)>;
 }
 ```
 #### `array` 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.ctor]], [[class.dtor]], and [[class.copy]]) to conform to the
 to the requirements specified in the container requirements table, the
 implicit move constructor and move assignment operator for `array`
 require that `T` be `MoveConstructible` or `MoveAssignable`,
 respectively.
+``` cpp
+template<class T, class... U>
+  array(T, U...) -> array<T, 1 + sizeof...(U)>;
+```
+*Requires:* `(is_same_v<T, U> && ...)` is `true`. Otherwise the program
+is ill-formed.
 #### `array` specialized algorithms <a id="array.special">[[array.special]]</a>
 ``` cpp
+template <class T, size_t N>
+  void swap(array<T, N>& x, array<T, N>& y) noexcept(noexcept(x.swap(y)));
 ```
+*Remarks:* This function shall not participate in overload resolution
+unless `N == 0` or `is_swappable_v<T>` is `true`.
+*Effects:* As if by `x.swap(y)`.
 *Complexity:* Linear in `N`.
 #### `array::size` <a id="array.size">[[array.size]]</a>
 ``` cpp
 template <class T, size_t N> constexpr size_type array<T, N>::size() const noexcept;
 ```
+*Returns:* `N`.
 #### `array::data` <a id="array.data">[[array.data]]</a>
 ``` cpp
+constexpr T* data() noexcept;
+constexpr const T* data() const noexcept;
 ```
+*Returns:* A pointer such that `data() == addressof(front())`, and
+\[`data()`, `data() + size()`) is a valid range.
 #### `array::fill` <a id="array.fill">[[array.fill]]</a>
 ``` cpp
 void fill(const T& u);
 ```
+*Effects:* As if by `fill_n(begin(), N, u)`.
 #### `array::swap` <a id="array.swap">[[array.swap]]</a>
 ``` cpp
+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*]
 #### Zero sized arrays <a id="array.zero">[[array.zero]]</a>
 `array` shall provide support for the special case `N == 0`.
 return value of `data()` is unspecified.
 The effect of calling `front()` or `back()` for a zero-sized array is
 undefined.
+Member function `swap()` shall have a non-throwing exception
+specification.
 #### Tuple interface to class template `array` <a id="array.tuple">[[array.tuple]]</a>
 ``` cpp
 template <class T, size_t N>
+ struct tuple_size<array<T, N>> : integral_constant<size_t, N> { };
 ```
 ``` cpp
 tuple_element<I, array<T, N>>::type
 ```
 *Value:* The type T.
 ``` cpp
 template <size_t I, class T, size_t N>
   constexpr T& get(array<T, N>& a) noexcept;
 template <size_t I, class T, size_t N>
   constexpr T&& get(array<T, N>&& a) noexcept;
 template <size_t I, class T, size_t N>
   constexpr const T& get(const array<T, N>& a) noexcept;
+template <size_t I, class T, size_t N>
+  constexpr const T&& get(const array<T, N>&& a) noexcept;
 ```
 *Requires:* `I < N`. The program is ill-formed if `I` is out of bounds.
+*Returns:* A reference to the `I`th element of `a`, where indexing is
+zero-based.
 ### Class template `deque` <a id="deque">[[deque]]</a>
 #### Class template `deque` overview <a id="deque.overview">[[deque.overview]]</a>
+A `deque` is a sequence container that supports random access iterators
+([[random.access.iterators]]). In addition, it supports constant time
 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` satisfies 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
 namespace std {
   template <class T, class Allocator = allocator<T>>
   class deque {
   public:
     // types:
+ using value_type             = T;
+ using allocator_type         = Allocator;
+ using pointer = typename allocator_traits<Allocator>::pointer;
+ using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
+ using reference              = value_type&;
+ using const_reference        = const value_type&;
+ using size_type              = implementation-defined; // 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>;
+    // [deque.cons], construct/copy/destroy
     deque() : deque(Allocator()) { }
     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(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>);
     const_iterator         cbegin() const noexcept;
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
+    // [deque.capacity], capacity
+    bool      empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
     void      resize(size_type sz);
     void      resize(size_type sz, const T& c);
     void      shrink_to_fit();
     // element access:
     reference       operator[](size_type n);
     const_reference operator[](size_type n) const;
     reference       at(size_type n);
     reference       front();
     const_reference front() const;
     reference       back();
     const_reference back() const;
+    // [deque.modifiers], modifiers
+    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 pop_front();
     void pop_back();
     iterator erase(const_iterator position);
     iterator erase(const_iterator first, const_iterator last);
+    void     swap(deque&)
+      noexcept(allocator_traits<Allocator>::is_always_equal::value);
     void     clear() noexcept;
   };
+  template<class InputIterator,
+           class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
+    deque(InputIterator, InputIterator, Allocator = Allocator())
+      -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>;
   template <class T, class Allocator>
     bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template <class T, class Allocator>
   template <class T, class Allocator>
     bool operator>=(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
+  // [deque.special], specialized algorithms
   template <class T, class Allocator>
+    void swap(deque<T, Allocator>& x, deque<T, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
 }
 ```
 #### `deque` constructors, copy, and assignment <a id="deque.cons">[[deque.cons]]</a>
 *Requires:* `T` shall be `DefaultInsertable` 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.
 *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.
 ``` cpp
 void resize(size_type sz);
 ```
+*Effects:* If `sz < size()`, erases the last `size() - sz` elements from
+the sequence. Otherwise, appends `sz - size()` default-inserted elements
+to the sequence.
 *Requires:* `T` shall be `MoveInsertable` and `DefaultInsertable` into
 `*this`.
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
+*Effects:* If `sz < size()`, erases the last `size() - sz` elements from
+the sequence. Otherwise, appends `sz - size()` copies of `c` to the
+sequence.
 *Requires:* `T` shall be `CopyInsertable` into `*this`.
 ``` cpp
 void shrink_to_fit();
 ```
 *Requires:* `T` shall be `MoveInsertable` into `*this`.
+*Effects:* `shrink_to_fit` is a non-binding request to reduce memory use
+but does not change the size of the sequence.
+[*Note 1*: The request is non-binding to allow latitude for
+implementation-specific optimizations. — *end note*]
+If an exception is thrown other than by the move constructor of a
+non-`CopyInsertable` `T` there are no effects.
 *Complexity:* Linear in the size of the sequence.
+*Remarks:* `shrink_to_fit` invalidates all the references, pointers, and
+iterators referring to the elements in the sequence as well as the
+past-the-end iterator.
 #### `deque` modifiers <a id="deque.modifiers">[[deque.modifiers]]</a>
 ``` cpp
 iterator insert(const_iterator position, 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);
 constructor of `T`.
 ``` cpp
 iterator erase(const_iterator position);
 iterator erase(const_iterator first, const_iterator last);
+void pop_front();
+void pop_back();
 ```
 *Effects:* An erase operation that erases the last element of a deque
 invalidates only the past-the-end iterator and all iterators and
 references to the erased elements. An erase operation that erases the
+first element of a deque but not the last element invalidates only
+iterators and references to the erased elements. An erase operation that
+erases neither the first element nor the last element of a deque
+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 copy constructor,
 move constructor, assignment operator, or move assignment operator of
 `T`.
 #### `deque` specialized algorithms <a id="deque.special">[[deque.special]]</a>
 ``` cpp
 template <class T, class Allocator>
+  void swap(deque<T, Allocator>& x, deque<T, Allocator>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
+*Effects:* As if by `x.swap(y)`.
 ### Class template `forward_list` <a id="forwardlist">[[forwardlist]]</a>
 #### Class template `forward_list` overview <a id="forwardlist.overview">[[forwardlist.overview]]</a>
 A `forward_list` is a container that supports forward iterators and
 allows constant time insert and erase operations anywhere within the
 sequence, with storage management handled automatically. Fast random
+access to list elements is not supported.
+[*Note 1*: It is intended that `forward_list` have zero space or time
+overhead relative to a hand-written C-style singly linked list. Features
+that would conflict with that goal have been omitted. — *end note*]
 A `forward_list` satisfies all of the requirements of a container
 (Table  [[tab:containers.container.requirements]]), except that the
 `size()` member function is not provided and `operator==` has linear
 complexity. A `forward_list` also satisfies all of the requirements for
 optional container requirements (Table
 [[tab:containers.sequence.optional]]). Descriptions are provided here
 only for operations on `forward_list` that are not described in that
 table or for operations where there is additional semantic information.
+[*Note 2*: Modifying any list requires access to the element preceding
+the first element of interest, but in a `forward_list` there is no
+constant-time way to access a preceding element. For this reason, ranges
+that are modified, such as those supplied to `erase` and `splice`, must
+be open at the beginning. — *end note*]
 ``` cpp
 namespace std {
   template <class T, class Allocator = allocator<T>>
   class forward_list {
   public:
     // types:
+ using value_type      = T;
+ using allocator_type  = Allocator;
+ using pointer         = typename allocator_traits<Allocator>::pointer;
+ using const_pointer   = typename allocator_traits<Allocator>::const_pointer;
+ using reference       = value_type&;
+ 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());
     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;
     // capacity:
     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, 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,
     template <class Compare> void sort(Compare comp);
     void reverse() noexcept;
   };
+ template<class InputIterator,
+           class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
+    forward_list(InputIterator, InputIterator, Allocator = Allocator())
+      -> forward_list<typename iterator_traits<InputIterator>::value_type, Allocator>;
   template <class T, class Allocator>
     bool operator==(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
   template <class T, class Allocator>
   template <class T, class Allocator>
     bool operator>=(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
+  // [forwardlist.spec], specialized algorithms
   template <class T, class Allocator>
+    void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
 }
 ```
+An incomplete type `T` may be used when instantiating `forward_list` if
+the allocator satisfies the allocator completeness requirements (
+[[allocator.requirements.completeness]]). `T` shall be complete before
+any member of the resulting specialization of `forward_list` is
+referenced.
 #### `forward_list` constructors, copy, assignment <a id="forwardlist.cons">[[forwardlist.cons]]</a>
 ``` cpp
 explicit forward_list(const Allocator&);
 ```
 to the copy or move constructor of `T` is exactly equal to `n`. Erasing
 `n` elements from a `forward_list` is linear in `n` and the number of
 calls to the destructor of type `T` is exactly equal to `n`.
 ``` cpp
+template <class... Args> reference emplace_front(Args&&... args);
 ```
 *Effects:* Inserts an object of type `value_type` constructed with
 `value_type(std::forward<Args>(args)...)` at the beginning of the list.
 ``` cpp
 void 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);
 ```
 void resize(size_type sz, const value_type& c);
 ```
 *Effects:* If `sz < distance(begin(), end())`, erases the last
 `distance(begin(), end()) - sz` elements from the list. Otherwise,
+inserts `sz - distance(begin(), end())` copies of `c` at the end of the
+list.
 *Requires:* `T` shall be `CopyInsertable` into `*this`.
 ``` cpp
 void clear() noexcept;
 the moved elements will continue to refer to their elements, but they
 now behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
+*Complexity:* 𝑂(`distance(x.begin(), x.end())`)
 ``` cpp
 void splice_after(const_iterator position, forward_list& x, const_iterator i);
 void splice_after(const_iterator position, forward_list&& x, const_iterator i);
 ```
 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:* 𝑂(`distance(first, last)`)
 ``` cpp
 void remove(const T& value);
 template <class Predicate> void remove_if(Predicate pred);
 ```
 *Effects:* Erases all the elements in the list referred by a list
 iterator `i` for which the following conditions hold: `*i == value` (for
+`remove()`), `pred(*i)` is `true` (for `remove_if()`). Invalidates only
 the iterators and references to the erased elements.
 *Throws:* Nothing unless an exception is thrown by the equality
 comparison or the predicate.
 but as members of `*this`. Iterators referring to the moved elements
 will continue to refer to their elements, but they now behave as
 iterators into `*this`, not into `x`.
 *Remarks:* Stable ([[algorithm.stable]]). The behavior is undefined if
+`get_allocator() != x.get_allocator()`.
 *Complexity:* At most
 `distance(begin(), end()) + distance(x.begin(), x.end()) - 1`
 comparisons.
 *Requires:* `operator<` (for the version with no arguments) or `comp`
 (for the version with a comparison argument) defines a strict weak
 ordering ([[alg.sorting]]).
 *Effects:* Sorts the list according to the `operator<` or the `comp`
+function object. If an exception is thrown, the order of the elements in
 `*this` is unspecified. Does not affect the validity of iterators and
 references.
 *Remarks:* Stable ([[algorithm.stable]]).
 #### `forward_list` specialized algorithms <a id="forwardlist.spec">[[forwardlist.spec]]</a>
 ``` cpp
 template <class T, class Allocator>
+  void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
+*Effects:* As if by `x.swap(y)`.
 ### Class template `list` <a id="list">[[list]]</a>
 #### Class template `list` overview <a id="list.overview">[[list.overview]]</a>
 namespace std {
   template <class T, class Allocator = allocator<T>>
   class list {
   public:
     // types:
+ using value_type             = T;
+ using allocator_type         = Allocator;
+ using pointer = typename allocator_traits<Allocator>::pointer;
+ using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
+ using reference              = value_type&;
+ 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>;
+    // [list.cons], construct/copy/destroy
     list() : list(Allocator()) { }
     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(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>);
     const_iterator         cbegin() const noexcept;
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
+    // [list.capacity], capacity
     bool      empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
     void      resize(size_type sz);
     void      resize(size_type sz, const T& c);
     reference       front();
     const_reference front() const;
     reference       back();
     const_reference back() const;
+    // [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);
                       InputIterator last);
     iterator insert(const_iterator position, initializer_list<T> il);
     iterator erase(const_iterator position);
     iterator erase(const_iterator position, const_iterator last);
+    void     swap(list&)
+      noexcept(allocator_traits<Allocator>::is_always_equal::value);
     void     clear() noexcept;
+    // [list.ops], list operations
     void splice(const_iterator position, list& x);
     void splice(const_iterator position, list&& x);
     void splice(const_iterator position, list& x, const_iterator i);
     void splice(const_iterator position, list&& x, const_iterator i);
     void splice(const_iterator position, list& x,
     template <class Compare> void sort(Compare comp);
     void reverse() noexcept;
   };
+  template<class InputIterator,
+           class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
+    list(InputIterator, InputIterator, Allocator = Allocator())
+      -> list<typename iterator_traits<InputIterator>::value_type, Allocator>;
   template <class T, class Allocator>
     bool operator==(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
   template <class T, class Allocator>
     bool operator>=(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const list<T, Allocator>& x, const list<T, Allocator>& y);
+  // [list.special], specialized algorithms
   template <class T, class Allocator>
+    void swap(list<T, Allocator>& x, list<T, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
 }
 ```
+An incomplete type `T` may be used when instantiating `list` if the
+allocator satisfies the allocator completeness requirements (
+[[allocator.requirements.completeness]]). `T` shall be complete before
+any member of the resulting specialization of `list` is referenced.
 #### `list` constructors, copy, and assignment <a id="list.cons">[[list.cons]]</a>
 ``` cpp
 explicit list(const Allocator&);
 ```
 *Requires:* `T` shall be `DefaultInsertable` into `*this`.
 *Complexity:* Linear in `n`.
 ``` cpp
+list(size_type n, const T& value, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `list` with `n` copies of `value`, using the
 specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 template <class InputIterator>
+ list(InputIterator first, InputIterator last, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `list` equal to the range \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
 ``` cpp
 void resize(size_type sz);
 ```
 *Effects:* If `size() < sz`, appends `sz - size()` default-inserted
+elements to the sequence. If `sz <= size()`, equivalent to:
 ``` cpp
 list<T>::iterator it = begin();
 advance(it, sz);
 erase(it, end());
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
+*Effects:* As if by:
 ``` cpp
 if (sz > size())
   insert(end(), sz-size(), c);
 else if (sz < size()) {
 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);
 ``` cpp
 void splice(const_iterator position, list& x, const_iterator i);
 void splice(const_iterator position, list&& x, const_iterator i);
 ```
+*Requires:* `i` is a valid dereferenceable iterator of `x`.
 *Effects:* Inserts an element pointed to by `i` from list `x` before
 `position` and removes the element from `x`. The result is unchanged if
 `position == i` or `position == ++i`. Pointers and references to `*i`
 continue to refer to this same element but as a member of `*this`.
 Iterators to `*i` (including `i` itself) continue to refer to the same
 element, but now behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* Constant time.
 ``` cpp
             const_iterator last);
 void splice(const_iterator position, list&& x, const_iterator first,
             const_iterator last);
 ```
+*Requires:* `[first, last)` is a valid range in `x`. The program has
+undefined behavior if `position` is an iterator in the range \[`first`,
+`last`).
 *Effects:* Inserts elements in the range \[`first`, `last`) before
+`position` and removes the elements from `x`. Pointers and references to
+the moved elements of `x` now refer to those same elements but as
+members of `*this`. Iterators referring to the moved elements will
+continue to refer to their elements, but they now behave as iterators
+into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* Constant time if `&x == this`; otherwise, linear time.
 *Effects:* If `(&x == this)` does nothing; otherwise, merges the two
 sorted ranges `[begin(), end())` and `[x.begin(), x.end())`. The result
 is a range in which the elements will be sorted in non-decreasing order
 according to the ordering defined by `comp`; that is, for every iterator
 `i`, in the range other than the first, the condition
+`comp(*i, *(i - 1))` will be `false`. Pointers and references to the
+moved elements of `x` now refer to those same elements but as members of
 `*this`. Iterators referring to the moved elements will continue to
 refer to their elements, but they now behave as iterators into `*this`,
 not into `x`.
 *Remarks:* Stable ([[algorithm.stable]]). If `(&x != this)` the range
 `[x.begin(), x.end())` is empty after the merge. No elements are copied
 by this operation. The behavior is undefined if
+`get_allocator() != x.get_allocator()`.
 *Complexity:* At most `size() + x.size() - 1` applications of `comp` if
 `(&x != this)`; otherwise, no applications of `comp` are performed. If
 an exception is thrown other than by a comparison there are no effects.
 *Requires:* `operator<` (for the first version) or `comp` (for the
 second version) shall define a strict weak ordering ([[alg.sorting]]).
 *Effects:* Sorts the list according to the `operator<` or a `Compare`
+function object. If an exception is thrown, the order of the elements in
+`*this` is unspecified. Does not affect the validity of iterators and
 references.
 *Remarks:* Stable ([[algorithm.stable]]).
+*Complexity:* Approximately N log N comparisons, where `N == size()`.
 #### `list` specialized algorithms <a id="list.special">[[list.special]]</a>
 ``` cpp
 template <class T, class Allocator>
+  void swap(list<T, Allocator>& x, list<T, Allocator>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
+*Effects:* As if by `x.swap(y)`.
 ### Class template `vector` <a id="vector">[[vector]]</a>
 #### Class template `vector` overview <a id="vector.overview">[[vector.overview]]</a>
+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` satisfies 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 (Table  [[tab:containers.allocatoraware]]),
+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.
 ``` cpp
 namespace std {
   template <class T, class Allocator = allocator<T>>
   class vector {
   public:
     // types:
+ using value_type             = T;
+ using allocator_type         = Allocator;
+ using pointer = typename allocator_traits<Allocator>::pointer;
+ using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
+ using reference              = value_type&;
+ using const_reference        = const value_type&;
+ using size_type              = implementation-defined; // 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>;
+    // [vector.cons], construct/copy/destroy
+    vector() noexcept(noexcept(Allocator())) : vector(Allocator()) { }
+    explicit vector(const Allocator&) noexcept;
     explicit vector(size_type n, const Allocator& = Allocator());
     vector(size_type n, const T& value, const Allocator& = Allocator());
     template <class InputIterator>
+      vector(InputIterator first, InputIterator last, const Allocator& = Allocator());
     vector(const vector& x);
+    vector(vector&&) noexcept;
     vector(const vector&, const Allocator&);
     vector(vector&&, const Allocator&);
     vector(initializer_list<T>, const Allocator& = Allocator());
     ~vector();
     vector& operator=(const vector& x);
+    vector& operator=(vector&& x)
+      noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+               allocator_traits<Allocator>::is_always_equal::value);
     vector& operator=(initializer_list<T>);
     template <class InputIterator>
       void assign(InputIterator first, InputIterator last);
     void assign(size_type n, const T& u);
     void assign(initializer_list<T>);
     const_iterator         cbegin() const noexcept;
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
+    // [vector.capacity], capacity
+    bool      empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
+    size_type capacity() const noexcept;
     void      resize(size_type sz);
     void      resize(size_type sz, const T& c);
     void      reserve(size_type n);
     void      shrink_to_fit();
     // element access:
     reference       operator[](size_type n);
     // [vector.data], data access
     T*       data() noexcept;
     const T* data() const noexcept;
+    // [vector.modifiers], modifiers
+    template <class... Args> reference emplace_back(Args&&... args);
     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 first, const_iterator last);
+    void     swap(vector&)
+      noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
+               allocator_traits<Allocator>::is_always_equal::value);
     void     clear() noexcept;
   };
+  template<class InputIterator,
+           class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
+    vector(InputIterator, InputIterator, Allocator = Allocator())
+      -> vector<typename iterator_traits<InputIterator>::value_type, Allocator>;
   template <class T, class Allocator>
     bool operator==(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator< (const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
   template <class T, class Allocator>
     bool operator>=(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template <class T, class Allocator>
     bool operator<=(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
+  // [vector.special], specialized algorithms
   template <class T, class Allocator>
+    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 satisfies the allocator completeness requirements (
+[[allocator.requirements.completeness]]). `T` shall be complete before
+any member of the resulting specialization of `vector` is referenced.
 #### `vector` constructors, copy, and assignment <a id="vector.cons">[[vector.cons]]</a>
 ``` cpp
 explicit vector(const Allocator&);
 ```
 *Effects:* Constructs a `vector` equal to the range \[`first`, `last`),
 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.
 #### `vector` capacity <a id="vector.capacity">[[vector.capacity]]</a>
 ``` cpp
 size_type capacity() const noexcept;
 void shrink_to_fit();
 ```
 *Requires:* `T` shall be `MoveInsertable` into `*this`.
+*Effects:* `shrink_to_fit` is a non-binding request to reduce
+`capacity()` to `size()`.
+[*Note 1*: The request is non-binding to allow latitude for
+implementation-specific optimizations. — *end note*]
+It does not increase `capacity()`, but may reduce `capacity()` by
+causing reallocation. If an exception is thrown other than by the move
+constructor of a non-`CopyInsertable` `T` there are no effects.
 *Complexity:* Linear in the size of the sequence.
+*Remarks:* Reallocation invalidates all the references, pointers, and
+iterators referring to the elements in the sequence as well as the
+past-the-end iterator. If no reallocation happens, they remain valid.
 ``` cpp
+void swap(vector& x)
+  noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
+           allocator_traits<Allocator>::is_always_equal::value);
 ```
 *Effects:* Exchanges the contents and `capacity()` of `*this` with that
 of `x`.
 ``` cpp
 void resize(size_type sz);
 ```
+*Effects:* If `sz < size()`, erases the last `size() - sz` elements from
+the sequence. Otherwise, appends `sz - size()` default-inserted elements
+to the sequence.
 *Requires:* `T` shall be `MoveInsertable` and `DefaultInsertable` into
 `*this`.
 *Remarks:* If an exception is thrown other than by the move constructor
 ``` cpp
 void resize(size_type sz, const T& c);
 ```
+*Effects:* If `sz < size()`, erases the last `size() - sz` elements from
+the sequence. Otherwise, appends `sz - size()` copies of `c` to the
+sequence.
 *Requires:* `T` shall be `CopyInsertable` into `*this`.
 *Remarks:* If an exception is thrown there are no effects.
 T*         data() noexcept;
 const T*   data() const noexcept;
 ```
 *Returns:* A pointer such that \[`data()`, `data() + size()`) is a valid
+range. For a non-empty vector, `data()` `==` `addressof(front())`.
 *Complexity:* Constant time.
 #### `vector` modifiers <a id="vector.modifiers">[[vector.modifiers]]</a>
 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_back(Args&&... args);
 template <class... Args> iterator emplace(const_iterator position, Args&&... args);
 void push_back(const T& x);
 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. If no reallocation
+happens, all the iterators and references before the insertion point
+remain valid. If an exception is thrown other than by the copy
+constructor, move constructor, assignment operator, or move assignment
+operator of `T` or by any `InputIterator` operation there are no
+effects. If an exception is thrown while inserting a single element at
+the end and `T` is `CopyInsertable` 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-`CopyInsertable` `T`, the effects are unspecified.
 *Complexity:* The complexity is linear in the number of elements
 inserted plus the distance to the end of the vector.
 ``` cpp
 iterator erase(const_iterator position);
 iterator erase(const_iterator first, const_iterator last);
+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`.
 #### `vector` specialized algorithms <a id="vector.special">[[vector.special]]</a>
 ``` cpp
 template <class T, class Allocator>
+  void swap(vector<T, Allocator>& x, vector<T, Allocator>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
+*Effects:* As if by `x.swap(y)`.
 ### 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;
       reference() noexcept;
     const_iterator         cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
     // capacity:
+    bool      empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
+    size_type capacity() const noexcept;
     void      resize(size_type sz, bool c = false);
     void      reserve(size_type n);
     void      shrink_to_fit();
     // element access:
     reference       operator[](size_type n);
     const_reference front() const;
     reference       back();
     const_reference back() const;
     // modifiers:
+    template <class... Args> reference emplace_back(Args&&... args);
     void push_back(const bool& x);
     void pop_back();
     template <class... Args> iterator emplace(const_iterator position, Args&&... args);
     iterator insert(const_iterator position, const bool& x);
     iterator insert(const_iterator position, size_type n, const bool& x);
 ```
 Unless described below, all operations have the same requirements and
 semantics as the primary `vector` template, except that operations
 dealing with the `bool` value type map to bit values in the container
+storage and `allocator_traits::construct` (
+[[allocator.traits.members]]) is not used to construct these values.
 There is no requirement that the data be stored as a contiguous
 allocation of `bool` values. A space-optimized representation of bits is
 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
 ``` cpp
 static void swap(reference x, reference y) noexcept;
 ```
+*Effects:* Exchanges the contents of `x` and `y` as if by:
 ``` cpp
 bool b = x;
 x = y;
 y = b;
 ``` cpp
 template <class Allocator> struct hash<vector<bool, Allocator>>;
 ```
+The specialization is enabled ([[unord.hash]]).

Diff to HTML by rtfpessoa