fixup: formatting

Author: jensmaurer

source/containers.tex

@@ -26,7 +26,7 @@
 \ref{unord}                  & Unordered associative containers &
   \tcode{<unordered_map>}, \tcode{<unordered_set>}    \\ \rowsep
 \ref{container.adaptors}     & Container adaptors               &
-  \tcode{<queue>}, \tcode{<stack>}, \tcode{<flat_map>}, \tcode{flat_set} \\ \rowsep
+  \tcode{<queue>}, \tcode{<stack>}, \tcode{<flat_map>}, \tcode{<flat_set>} \\ \rowsep
 \ref{views}                  & Views                            & \tcode{<span>} \\
 \end{libsumtab}
 
@@ -14783,12 +14783,12 @@
     flat_map(sorted_unique_t, InputIterator, InputIterator, Compare = Compare())
       -> flat_map<@\exposid{iter-key-type}@<InputIterator>, @\exposid{iter-mapped-type}@<InputIterator>, Compare>;
 
-  template<ranges::input_range R, class Compare = less<@\exposid{range-key-type}@<R>>,
+  template<ranges::@\libconcept{input_range}@ R, class Compare = less<@\exposid{range-key-type}@<R>>,
            class Allocator>
     flat_map(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
       -> flat_map<@\exposid{range-key-type}@<R>, @\exposid{range-mapped-type}@<R>, Compare>;
 
-  template<ranges::input_range R, class Allocator>
+  template<ranges::@\libconcept{input_range}@ R, class Allocator>
     flat_map(from_range_t, R&&, Allocator)
       -> flat_map<@\exposid{range-key-type}@<R>, @\exposid{range-mapped-type}@<R>>;
 
@@ -15890,12 +15890,12 @@
     flat_multimap(sorted_equivalent_t, InputIterator, InputIterator, Compare = Compare())
       -> flat_multimap<@\exposid{iter-key-type}@<InputIterator>, @\exposid{iter-mapped-type}@<InputIterator>, Compare>;
 
-  template<ranges::input_range R, class Compare = less<@\exposid{range-key-type}@<R>>,
+  template<ranges::@\libconcept{input_range}@ R, class Compare = less<@\exposid{range-key-type}@<R>>,
            class Allocator>
     flat_multimap(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
       -> flat_multimap<@\exposid{range-key-type}@<R>, @\exposid{range-mapped-type}@<R>, Compare>;
 
-  template<ranges::input_range R, class Allocator>
+  template<ranges::@\libconcept{input_range}@ R, class Allocator>
     flat_multimap(from_range_t, R&&, Allocator)
       -> flat_multimap<@\exposid{range-key-type}@<R>, @\exposid{range-mapped-type}@<R>>;
 
@@ -16105,7 +16105,7 @@
     class flat_set;
 
   struct sorted_unique_t { explicit sorted_unique_t() = default; };
-  inline constexpr sorted_unique_t sorted_unique {};
+  inline constexpr sorted_unique_t sorted_unique{};
 
   template<class Key, class Compare, class KeyContainer, class Predicate>
     size_t erase_if(flat_set<Key, Compare, KeyContainer>& c, Predicate pred);
@@ -16118,7 +16118,7 @@
     class flat_multiset;
 
   struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };
-  inline constexpr sorted_equivalent_t sorted_equivalent {};
+  inline constexpr sorted_equivalent_t sorted_equivalent{};
 
   template<class Key, class Compare, class KeyContainer, class Predicate>
     size_t erase_if(flat_multiset<Key, Compare, KeyContainer>& c, Predicate pred);
@@ -16144,7 +16144,7 @@
 
 \pnum
 A \tcode{flat_set} meets all of the requirements
-for a container \iref{container.reqmts} and
+for a container\iref{container.reqmts} and
 for a reversible container\iref{container.rev.reqmts},
 plus the optional container requirements\iref{container.opt.reqmts}.
 \tcode{flat_set} meets the requirements of
@@ -16164,12 +16164,12 @@
 \begin{note}
 A \tcode{flat_set} does not meet
 the additional requirements of an allocator-aware container,
-as described in\iref{container.alloc.reqmts}.
+as described in \ref{container.alloc.reqmts}.
 \end{note}
 
 \pnum
 A \tcode{flat_set} also provides most operations
-described in\iref{associative.reqmts} for unique keys.
+described in \ref{associative.reqmts} for unique keys.
 This means that a \tcode{flat_set} supports
 the \tcode{a_uniq} operations in \ref{associative.reqmts},
 but not support the \tcode{a_eq} operations.
@@ -16186,14 +16186,14 @@
 respect to the comparison object.
 
 \pnum
-If any member function in \ref{flat.set} exits via an exception,
+If any member function in \ref{flat.set.defn} exits via an exception,
 the invariant is restored.
 \begin{note}
 This can result in the \tcode{flat_set}'s being emptied.
 \end{note}
 
 \pnum
-Any sequence container \ref{sequence.reqmts}
+Any sequence container\iref{sequence.reqmts}
 supporting \oldconcept{RandomAccessIterator}
 can be used to instantiate \tcode{flat_set}.
 In particular, \tcode{vector}\iref{vector} and \tcode{deque}\iref{deque}
@@ -16269,11 +16269,11 @@
         : flat_set(fr, std::forward<R>(range), key_compare()) { }
     template<@\exposconcept{container-compatible-range}@<value_type> R, class Allocator>
       flat_set(from_range_t, R&& rg, const Allocator& a);
-    template<@\placeholder{container-compatible-range}@<value_type> R>
+    template<@\exposconcept{container-compatible-range}@<value_type> R>
       flat_set(from_range_t, R&& rg, const key_compare& comp)
         : flat_set(comp)
         { insert_range(std::forward<R>(range)); }
-    template<@\placeholder{container-compatible-range}@<value_type> R, class Allocator>
+    template<@\exposconcept{container-compatible-range}@<value_type> R, class Allocator>
        flat_set(from_range_t, R&& rg, const key_compare& comp,
                 const Allocator& a);
 
@@ -16350,7 +16350,7 @@
       void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
       void insert(sorted_unique_t, InputIterator first, InputIterator last);
-    template<@\placeholder{container-compatible-range}@<value_type> R>
+    template<@\exposconcept{container-compatible-range}@<value_type> R>
       void insert_range(R&& rg);
 
     void insert(initializer_list<key_type> il)
@@ -16405,8 +16405,8 @@
 
     friend bool operator==(const flat_set& x, const flat_set& y);
 
-    friend @\exposconcept{synth-three-way-result}@<value_type>
-    operator<=>(const flat_set& x, const flat_set& y);
+    friend @\placeholder{synth-three-way-result}@<value_type>
+      operator<=>(const flat_set& x, const flat_set& y);
 
     friend void swap(flat_set& x, flat_set& y) noexcept { x.swap(y); }
 
@@ -16423,12 +16423,12 @@
     flat_set(sorted_unique_t, InputIterator, InputIterator, Compare = Compare())
       -> flat_set<@\placeholder{iter-value-type}@<InputIterator>, Compare>;
 
-  template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>,
+  template<ranges::@\libconcept{input_range}@ R, class Compare = less<ranges::range_value_t<R>>,
           class Allocator = allocator<ranges::range_value_t<R>>>
     flat_set(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
       -> flat_set<ranges::range_value_t<R>, Compare>;
 
-   template<ranges::input_range R, class Allocator>
+   template<ranges::@\libconcept{input_range}@ R, class Allocator>
      flat_set(from_range_t, R&&, Allocator)
        -> flat_set<ranges::range_value_t<R>, less<ranges::range_value_t<R>>>;
 
@@ -16588,7 +16588,7 @@
 the \tcode{bool} component of the returned pair is \tcode{true}
 if and only if the insertion took place.
 The returned iterator points to the element
-whose key is equivalent to \tcode{k}.
+whose key is equivalent to \tcode{x}.
 \end{itemdescr}
 
 \indexlibrarymember{insert}{flatset}%
@@ -16648,7 +16648,7 @@
 \effects
 Adds elements to \exposid{c} as if by:
 \begin{codeblock}
-for (const auto& e : range) {
+for (const auto& e : rg) {
   c.insert(c.end(), e);
 }
 \end{codeblock}
@@ -16689,11 +16689,11 @@
 container_type extract() &&;
 \end{itemdecl}
 
+\begin{itemdescr}
 \pnum
 \ensures
 \tcode{*this} is emptied, even if the function exits via an exception.
 
-\begin{itemdescr}
 \pnum
 \returns
 \tcode{std::move(c)}.
@@ -16740,7 +16740,7 @@
 \rSec3[flat.multiset.overview]{Overview}
 
 \pnum
-\indexlibraryglobal{flat.multiset}%
+\indexlibraryglobal{flat_multiset}%
 A \tcode{flat_multiset} is a container adaptor
 that provides an associative container interface
 that supports equivalent keys
@@ -16796,11 +16796,11 @@
 If any member function in \ref{flat.multiset.defn} exits via an exception,
 the invariant is restored.
 \begin{note}
-This cat result in the \tcode{flat_multiset}'s being emptied.
+This can result in the \tcode{flat_multiset}'s being emptied.
 \end{note}
 
 \pnum
-Any sequence container \ref{sequence.reqmts}
+Any sequence container\iref{sequence.reqmts}
 supporting \oldconcept{RandomAccessIterator}
 can be used to instantiate \tcode{flat_multiset}.
 In particular,
@@ -17010,8 +17010,8 @@
 
     friend bool operator==(const flat_multiset& x, const flat_multiset& y);
 
-    friend @\exposconcept{synth-three-way-result}@<value_type>
-    operator<=>(const flat_multiset& x, const flat_multiset& y);
+    friend @\placeholder{synth-three-way-result}@<value_type>
+      operator<=>(const flat_multiset& x, const flat_multiset& y);
 
     friend void swap(flat_multiset& x, flat_multiset& y) noexcept
       { x.swap(y); }
@@ -17021,20 +17021,20 @@
     key_compare @\exposid{compare}@;    // \expos
   };
 
-  template<class InputIterator, class Compare = less<@\exposid{iter-value-type}@<InputIterator>>>
+  template<class InputIterator, class Compare = less<@\placeholder{iter-value-type}@<InputIterator>>>
     flat_multiset(InputIterator, InputIterator, Compare = Compare())
-      -> flat_multiset<@\placeholder{iter-value-type}@<InputIterator>, @\exposid{iter-value-type}@<InputIterator>, Compare>;
+      -> flat_multiset<@\placeholder{iter-value-type}@<InputIterator>, @\placeholder{iter-value-type}@<InputIterator>, Compare>;
 
-  template<class InputIterator, class Compare = less<@\exposid{iter-value-type}@<InputIterator>>>
+  template<class InputIterator, class Compare = less<@\placeholder{iter-value-type}@<InputIterator>>>
     flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, Compare = Compare())
-      -> flat_multiset<@\placeholder{iter-value-type}@<InputIterator>, @\exposid{iter-value-type}@<InputIterator>, Compare>;
+      -> flat_multiset<@\placeholder{iter-value-type}@<InputIterator>, @\placeholder{iter-value-type}@<InputIterator>, Compare>;
 
-  template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>,
-          class Allocator = allocator<ranges::range_value_t<R>>>
+  template<ranges::@\libconcept{input_range}@ R, class Compare = less<ranges::range_value_t<R>>,
+           class Allocator = allocator<ranges::range_value_t<R>>>
     flat_multiset(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
       -> flat_multiset<ranges::range_value_t<R>, Compare>;
 
-   template<ranges::input_range R, class Allocator>
+   template<ranges::@\libconcept{input_range}@ R, class Allocator>
      flat_multiset(from_range_t, R&&, Allocator)
        -> flat_multiset<ranges::range_value_t<R>, less<ranges::range_value_t<R>>>;
 
@@ -17276,10 +17276,7 @@
 
 \pnum
 \effects
-Equivalent to:
-\begin{codeblock}
-c = std::move(cont);
-\end{codeblock}
+Equivalent to: \tcode{c = std::move(cont);}
 \end{itemdescr}
 
 \rSec3[flat.multiset.erasure]{Erasure}