From af9877109777e528e539e6f892cb79f800057f98 Mon Sep 17 00:00:00 2001
From: Casey Carter <Casey@Carter.net>
Date: Wed, 27 Jun 2018 16:39:54 -0700
Subject: [PATCH] [algorithm.syn] Relocate the "partitions" algorithms between
 the "binary_search" family and the "merge" family, to agree with the order of
 the detailed specifiations as reordered by #1245.

Fixes #2218.
---
 source/algorithms.tex | 86 +++++++++++++++++++++----------------------
 1 file changed, 43 insertions(+), 43 deletions(-)

diff --git a/source/algorithms.tex b/source/algorithms.tex
index 294cafb974..ae2f881e35 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -585,49 +585,6 @@
                   ForwardIterator first, ForwardIterator last,
                   typename iterator_traits<ForwardIterator>::difference_type n);
 
-  // \ref{alg.partitions}, partitions
-  template<class InputIterator, class Predicate>
-    constexpr bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);
-  template<class ExecutionPolicy, class ForwardIterator, class Predicate>
-    bool is_partitioned(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-                        ForwardIterator first, ForwardIterator last, Predicate pred);
-
-  template<class ForwardIterator, class Predicate>
-    constexpr ForwardIterator partition(ForwardIterator first,
-                                        ForwardIterator last,
-                                        Predicate pred);
-  template<class ExecutionPolicy, class ForwardIterator, class Predicate>
-    ForwardIterator partition(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-                              ForwardIterator first,
-                              ForwardIterator last,
-                              Predicate pred);
-  template<class BidirectionalIterator, class Predicate>
-    BidirectionalIterator stable_partition(BidirectionalIterator first,
-                                           BidirectionalIterator last,
-                                           Predicate pred);
-  template<class ExecutionPolicy, class BidirectionalIterator, class Predicate>
-    BidirectionalIterator stable_partition(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-                                           BidirectionalIterator first,
-                                           BidirectionalIterator last,
-                                           Predicate pred);
-  template<class InputIterator, class OutputIterator1,
-           class OutputIterator2, class Predicate>
-    constexpr pair<OutputIterator1, OutputIterator2>
-      partition_copy(InputIterator first, InputIterator last,
-                     OutputIterator1 out_true, OutputIterator2 out_false,
-                     Predicate pred);
-  template<class ExecutionPolicy, class ForwardIterator, class ForwardIterator1,
-           class ForwardIterator2, class Predicate>
-    pair<ForwardIterator1, ForwardIterator2>
-      partition_copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
-                     ForwardIterator first, ForwardIterator last,
-                     ForwardIterator1 out_true, ForwardIterator2 out_false,
-                     Predicate pred);
-  template<class ForwardIterator, class Predicate>
-    constexpr ForwardIterator
-      partition_point(ForwardIterator first, ForwardIterator last,
-                      Predicate pred);
-
   // \ref{alg.sorting}, sorting and related operations
   // \ref{alg.sort}, sorting
   template<class RandomAccessIterator>
@@ -781,6 +738,49 @@
       binary_search(ForwardIterator first, ForwardIterator last,
                     const T& value, Compare comp);
 
+  // \ref{alg.partitions}, partitions
+  template<class InputIterator, class Predicate>
+    constexpr bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);
+  template<class ExecutionPolicy, class ForwardIterator, class Predicate>
+    bool is_partitioned(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+                        ForwardIterator first, ForwardIterator last, Predicate pred);
+
+  template<class ForwardIterator, class Predicate>
+    constexpr ForwardIterator partition(ForwardIterator first,
+                                        ForwardIterator last,
+                                        Predicate pred);
+  template<class ExecutionPolicy, class ForwardIterator, class Predicate>
+    ForwardIterator partition(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+                              ForwardIterator first,
+                              ForwardIterator last,
+                              Predicate pred);
+  template<class BidirectionalIterator, class Predicate>
+    BidirectionalIterator stable_partition(BidirectionalIterator first,
+                                           BidirectionalIterator last,
+                                           Predicate pred);
+  template<class ExecutionPolicy, class BidirectionalIterator, class Predicate>
+    BidirectionalIterator stable_partition(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+                                           BidirectionalIterator first,
+                                           BidirectionalIterator last,
+                                           Predicate pred);
+  template<class InputIterator, class OutputIterator1,
+           class OutputIterator2, class Predicate>
+    constexpr pair<OutputIterator1, OutputIterator2>
+      partition_copy(InputIterator first, InputIterator last,
+                     OutputIterator1 out_true, OutputIterator2 out_false,
+                     Predicate pred);
+  template<class ExecutionPolicy, class ForwardIterator, class ForwardIterator1,
+           class ForwardIterator2, class Predicate>
+    pair<ForwardIterator1, ForwardIterator2>
+      partition_copy(ExecutionPolicy&& exec, // see \ref{algorithms.parallel.overloads}
+                     ForwardIterator first, ForwardIterator last,
+                     ForwardIterator1 out_true, ForwardIterator2 out_false,
+                     Predicate pred);
+  template<class ForwardIterator, class Predicate>
+    constexpr ForwardIterator
+      partition_point(ForwardIterator first, ForwardIterator last,
+                      Predicate pred);
+
   // \ref{alg.merge}, merge
   template<class InputIterator1, class InputIterator2, class OutputIterator>
     constexpr OutputIterator