[flat.multimap] P2767R0 section 3 swaps requested by jwakely in LWG

Swap the default ctor to the top.
Follow each non-`key_compare` overload by its `key_compare` counterpart.
Then, follow each non-`sorted_unique` pair of overloads by its `sorted_unique` counterparts.

Author: Quuxplusone

source/containers.tex

@@ -16393,34 +16393,34 @@
     // \ref{flat.multimap.cons}, constructors
     flat_multimap() : flat_multimap(key_compare()) { }
 
+    explicit flat_multimap(const key_compare& comp)
+      : c(), compare(comp) { }
+
     flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
                   const key_compare& comp = key_compare());
 
     flat_multimap(sorted_equivalent_t,
                   key_container_type key_cont, mapped_container_type mapped_cont,
                   const key_compare& comp = key_compare());
 
-    explicit flat_multimap(const key_compare& comp)
-      : c(), compare(comp) { }
-
     template<class InputIterator>
       flat_multimap(InputIterator first, InputIterator last,
                     const key_compare& comp = key_compare())
         : c(), compare(comp)
         { insert(first, last); }
 
+    template<class InputIterator>
+      flat_multimap(sorted_equivalent_t s, InputIterator first, InputIterator last,
+                    const key_compare& comp = key_compare())
+        : c(), compare(comp) { insert(s, first, last); }
+
     template<@\exposconcept{container-compatible-range}@<value_type> R>
       flat_multimap(from_range_t fr, R&& rg)
         : flat_multimap(fr, std::forward<R>(rg), key_compare()) { }
     template<@\exposconcept{container-compatible-range}@<value_type> R>
       flat_multimap(from_range_t, R&& rg, const key_compare& comp)
         : flat_multimap(comp) { insert_range(std::forward<R>(rg)); }
 
-    template<class InputIterator>
-      flat_multimap(sorted_equivalent_t s, InputIterator first, InputIterator last,
-                    const key_compare& comp = key_compare())
-        : c(), compare(comp) { insert(s, first, last); }
-
     flat_multimap(initializer_list<value_type> il, const key_compare& comp = key_compare())
         : flat_multimap(il.begin(), il.end(), comp) { }
 
@@ -16431,9 +16431,9 @@
     // \ref{flat.multimap.cons.alloc}, constructors with allocators
 
     template<class Alloc>
-      flat_multimap(const flat_multimap&, const Alloc& a);
+      explicit flat_multimap(const Alloc& a);
     template<class Alloc>
-      flat_multimap(flat_multimap&&, const Alloc& a);
+      flat_multimap(const key_compare& comp, const Alloc& a);
     template<class Alloc>
       flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
                     const Alloc& a);
@@ -16448,34 +16448,34 @@
                     const mapped_container_type& mapped_cont,
                     const key_compare& comp, const Alloc& a);
     template<class Alloc>
-      flat_multimap(const key_compare& comp, const Alloc& a);
+      flat_multimap(const flat_multimap&, const Alloc& a);
     template<class Alloc>
-      explicit flat_multimap(const Alloc& a);
+      flat_multimap(flat_multimap&&, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      flat_multimap(InputIterator first, InputIterator last, const Alloc& a);
     template<class InputIterator, class Alloc>
       flat_multimap(InputIterator first, InputIterator last,
                     const key_compare& comp, const Alloc& a);
     template<class InputIterator, class Alloc>
-      flat_multimap(InputIterator first, InputIterator last, const Alloc& a);
+      flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
+                    const Alloc& a);
+    template<class InputIterator, class Alloc>
+      flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
+                    const key_compare& comp, const Alloc& a);
     template<@\exposconcept{container-compatible-range}@<value_type> R, class Alloc>
       flat_multimap(from_range_t, R&& rg, const Alloc& a);
     template<@\exposconcept{container-compatible-range}@<value_type> R, class Alloc>
       flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
-    template<class InputIterator, class Alloc>
-      flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
-                    const key_compare& comp, const Alloc& a);
-    template<class InputIterator, class Alloc>
-      flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
-                    const Alloc& a);
+    template<class Alloc>
+      flat_multimap(initializer_list<value_type> il, const Alloc& a);
     template<class Alloc>
       flat_multimap(initializer_list<value_type> il, const key_compare& comp,
                     const Alloc& a);
     template<class Alloc>
-      flat_multimap(initializer_list<value_type> il, const Alloc& a);
+      flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Alloc& a);
     template<class Alloc>
       flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
                     const key_compare& comp, const Alloc& a);
-    template<class Alloc>
-      flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Alloc& a);
 
     flat_multimap& operator=(initializer_list<value_type>);
 
@@ -16768,37 +16768,37 @@
 \indexlibraryctor{flat_multimap}%
 \begin{itemdecl}
 template<class Alloc>
-  flat_multimap(const flat_multimap&, const Alloc& a);
-template<class Alloc>
-  flat_multimap(flat_multimap&&, const Alloc& a);
+  explicit flat_multimap(const Alloc& a);
 template<class Alloc>
   flat_multimap(const key_compare& comp, const Alloc& a);
 template<class Alloc>
-  explicit flat_multimap(const Alloc& a);
+  flat_multimap(const flat_multimap&, const Alloc& a);
+template<class Alloc>
+  flat_multimap(flat_multimap&&, const Alloc& a);
+template<class InputIterator, class Alloc>
+  flat_multimap(InputIterator first, InputIterator last, const Alloc& a);
 template<class InputIterator, class Alloc>
   flat_multimap(InputIterator first, InputIterator last, const key_compare& comp,
                 const Alloc& a);
 template<class InputIterator, class Alloc>
-  flat_multimap(InputIterator first, InputIterator last, const Alloc& a);
+  flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
+                const Alloc& a);
+template<class InputIterator, class Alloc>
+  flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
+                const key_compare& comp, const Alloc& a);
 template<@\exposconcept{container-compatible-range}@<value_type> R, class Alloc>
   flat_multimap(from_range_t, R&& rg, const Alloc& a);
 template<@\exposconcept{container-compatible-range}@<value_type> R, class Alloc>
   flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
-template<class InputIterator, class Alloc>
-  flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
-                const key_compare& comp, const Alloc& a);
-template<class InputIterator, class Alloc>
-  flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
-                const Alloc& a);
+template<class Alloc>
+  flat_multimap(initializer_list<value_type> il, const Alloc& a);
 template<class Alloc>
   flat_multimap(initializer_list<value_type> il, const key_compare& comp, const Alloc& a);
 template<class Alloc>
-  flat_multimap(initializer_list<value_type> il, const Alloc& a);
+  flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Alloc& a);
 template<class Alloc>
   flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
                 const key_compare& comp, const Alloc& a);
-template<class Alloc>
-  flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Alloc& a);
 \end{itemdecl}
 
 \begin{itemdescr}