[alg.modifying.operations] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpxjoga6l8/{from.md → to.md} +585 -123

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

@@ -31,25 +31,43 @@ range \[`result`, `result + `N) starting from `first` and proceeding to
 *Complexity:* Exactly N assignments.
 ``` cpp
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-  ForwardIterator2 copy(ExecutionPolicy&& policy,
                         ForwardIterator1 first, ForwardIterator1 last,
                         ForwardIterator2 result);
 ```
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) do not overlap.
-*Effects:* Copies elements in the range \[`first`, `last`) into the
-range \[`result`, `result + (last - first)`). For each non-negative
-integer `n < (last - first)`, performs `*(result + n) = *(first + n)`.
-*Returns:* `result + (last - first)`.
-*Complexity:* Exactly `last - first` assignments.
 ``` cpp
 template<class InputIterator, class Size, class OutputIterator>
   constexpr OutputIterator copy_n(InputIterator first, Size n,
                                   OutputIterator result);
@@ -60,13 +78,24 @@ template<class ExecutionPolicy, class ForwardIterator1, class Size, class Forwar
 template<input_iterator I, weakly_incrementable O>
   requires indirectly_copyable<I, O>
   constexpr ranges::copy_n_result<I, O>
     ranges::copy_n(I first, iter_difference_t<I> n, O result);
 ```
-Let N be max(0, `n`).
 *Mandates:* The type `Size` is convertible to an integral
 type [[conv.integral]], [[class.conv]].
 *Effects:* For each non-negative integer i < N, performs
@@ -97,38 +126,66 @@ template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj
 template<input_range R, weakly_incrementable O, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::copy_if_result<borrowed_iterator_t<R>, O>
     ranges::copy_if(R&& r, O result, Pred pred, Proj proj = {});
 ```
-Let E be:
 - `bool(pred(*i))` for the overloads in namespace `std`;
 - `bool(invoke(pred, invoke(proj, *i)))` for the overloads in namespace
-  `ranges`,
-and N be the number of iterators `i` in the range \[`first`, `last`) for
-which the condition E holds.
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) do not overlap.
-[*Note 1*: For the overload with an `ExecutionPolicy`, there might be a
-performance cost if `iterator_traits<ForwardIterator1>::value_type` is
-not *Cpp17MoveConstructible*
-([[cpp17.moveconstructible]]). — *end note*]
-*Effects:* Copies all of the elements referred to by the iterator `i` in
-the range \[`first`, `last`) for which E is `true`.
 *Returns:*
 - `result + `N for the overloads in namespace `std`.
-- `{last, result + `N`}` for the overloads in namespace `ranges`.
-*Complexity:* Exactly `last - first` applications of the corresponding
 predicate and any projection.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
@@ -181,11 +238,11 @@ template<input_range R, weakly_incrementable O>
   requires indirectly_movable<iterator_t<R>, O>
   constexpr ranges::move_result<borrowed_iterator_t<R>, O>
     ranges::move(R&& r, O result);
 ```
-Let E be
 - `std::move(*(first + `n`))` for the overload in namespace `std`;
 - `ranges::iter_move(first + `n`)` for the overloads in namespace
   `ranges`.
@@ -194,36 +251,58 @@ Let N be `last - first`.
 *Preconditions:* `result` is not in the range \[`first`, `last`).
 *Effects:* Moves elements in the range \[`first`, `last`) into the range
 \[`result`, `result + `N) starting from `first` and proceeding to
 `last`. For each non-negative integer n < N, performs
-`*(result + `n`) = `E.
 *Returns:*
 - `result + `N for the overload in namespace `std`.
 - `{last, result + `N`}` for the overloads in namespace `ranges`.
 *Complexity:* Exactly N assignments.
 ``` cpp
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-  ForwardIterator2 move(ExecutionPolicy&& policy,
                         ForwardIterator1 first, ForwardIterator1 last,
                         ForwardIterator2 result);
 ```
-Let N be `last - first`.
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
 `result + `N) do not overlap.
-*Effects:* Moves elements in the range \[`first`, `last`) into the range
-\[`result`, `result + `N). For each non-negative integer n < N, performs
-`*(result + `n`) = std::move(*(first + `n`))`.
-*Returns:* `result + `N.
 *Complexity:* Exactly N assignments.
 ``` cpp
 template<class BidirectionalIterator1, class BidirectionalIterator2>
@@ -239,11 +318,11 @@ template<bidirectional_range R, bidirectional_iterator I>
   requires indirectly_movable<iterator_t<R>, I>
   constexpr ranges::move_backward_result<borrowed_iterator_t<R>, I>
     ranges::move_backward(R&& r, I result);
 ```
-Let E be
 - `std::move(*(last - `n`))` for the overload in namespace `std`;
 - `ranges::iter_move(last - `n`)` for the overloads in namespace
   `ranges`.
@@ -253,11 +332,11 @@ Let N be `last - first`.
 *Effects:* Moves elements in the range \[`first`, `last`) into the range
 \[`result - `N, `result`) starting from `last - 1` and proceeding to
 `first`.[^3]
-For each positive integer n ≤ N, performs `*(result - `n`) = `E.
 *Returns:*
 - `result - `N for the overload in namespace `std`.
 - `{last, result - `N`}` for the overloads in namespace `ranges`.
@@ -283,16 +362,26 @@ template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for
     ranges::swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
 template<input_range R1, input_range R2>
   requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
   constexpr ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
     ranges::swap_ranges(R1&& r1, R2&& r2);
 ```
 Let:
-- `last2` be `first2 + (last1 - first1)` for the overloads with no
-  parameter named `last2`;
 - M be min(`last1 - first1`,  `last2 - first2`).
 *Preconditions:* The two ranges \[`first1`, `last1`) and \[`first2`,
 `last2`) do not overlap. For the overloads in namespace `std`,
 `*(first1 + `n`)` is swappable with [[swappable.requirements]]
@@ -360,10 +449,25 @@ template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
 template<input_range R, weakly_incrementable O, copy_constructible F,
          class Proj = identity>
   requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
   constexpr ranges::unary_transform_result<borrowed_iterator_t<R>, O>
     ranges::transform(R&& r, O result, F op, Proj proj = {});
 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
          weakly_incrementable O, copy_constructible F, class Proj1 = identity,
          class Proj2 = identity>
   requires indirectly_writable<O, indirect_result_t<F&, projected<I1, Proj1>,
                                projected<I2, Proj2>>>
@@ -375,104 +479,165 @@ template<input_range R1, input_range R2, weakly_incrementable O,
   requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
                                projected<iterator_t<R2>, Proj2>>>
   constexpr ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
     ranges::transform(R1&& r1, R2&& r2, O result,
                       F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let:
-- `last2` be `first2 + (last1 - first1)` for the overloads with
-  parameter `first2` but no parameter `last2`;
-- N be `last1 - first1` for unary transforms, or
   min(`last1 - first1`,  `last2 - first2`) for binary transforms;
-- E be
   - `op(*(first1 + (i - result)))` for unary transforms defined in
     namespace `std`;
   - `binary_op(*(first1 + (i - result)), *(first2 + (i - result)))` for
     binary transforms defined in namespace `std`;
   - `invoke(op, invoke(proj, *(first1 + (i - result))))` for unary
     transforms defined in namespace `ranges`;
   - `invoke(binary_op, invoke(proj1, *(first1 + (i - result))), invoke(proj2,*(first2 + (i - result))))`
     for binary transforms defined in namespace `ranges`.
-*Preconditions:* `op` and `binary_op` do not invalidate iterators or
-subranges, nor modify elements in the ranges
 - \[`first1`, `first1 + `N\],
 - \[`first2`, `first2 + `N\], and
 - \[`result`, `result + `N\].[^4]
 *Effects:* Assigns through every iterator `i` in the range \[`result`,
-`result + `N) a new corresponding value equal to E.
 *Returns:*
 - `result + `N for the overloads defined in namespace `std`.
 - `{first1 + `N`, result + `N`}` for unary transforms defined in
   namespace `ranges`.
 - `{first1 + `N`, first2 + `N`, result + `N`}` for binary transforms
   defined in namespace `ranges`.
 *Complexity:* Exactly N applications of `op` or `binary_op`, and any
-projections. This requirement also applies to the overload with an
-`ExecutionPolicy`.
 *Remarks:* `result` may be equal to `first1` or `first2`.
 ### Replace <a id="alg.replace">[[alg.replace]]</a>
 ``` cpp
-template<class ForwardIterator, class T>
   constexpr void replace(ForwardIterator first, ForwardIterator last,
                          const T& old_value, const T& new_value);
-template<class ExecutionPolicy, class ForwardIterator, class T>
   void replace(ExecutionPolicy&& exec,
                ForwardIterator first, ForwardIterator last,
                const T& old_value, const T& new_value);
-template<class ForwardIterator, class Predicate, class T>
   constexpr void replace_if(ForwardIterator first, ForwardIterator last,
                             Predicate pred, const T& new_value);
-template<class ExecutionPolicy, class ForwardIterator, class Predicate, class T>
   void replace_if(ExecutionPolicy&& exec,
                   ForwardIterator first, ForwardIterator last,
                   Predicate pred, const T& new_value);
-template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
   requires indirectly_writable<I, const T2&> &&
            indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
   constexpr I
     ranges::replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});
-template<input_range R, class T1, class T2, class Proj = identity>
   requires indirectly_writable<iterator_t<R>, const T2&> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
   constexpr borrowed_iterator_t<R>
     ranges::replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});
-template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   requires indirectly_writable<I, const T&>
   constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
-template<input_range R, class T, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires indirectly_writable<iterator_t<R>, const T&>
   constexpr borrowed_iterator_t<R>
     ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
 ```
-Let E be
 - `bool(*i == old_value)` for `replace`;
 - `bool(pred(*i))` for `replace_if`;
 - `bool(invoke(proj, *i) == old_value)` for `ranges::replace`;
 - `bool(invoke(pred, invoke(proj, *i)))` for `ranges::replace_if`.
 *Mandates:* `new_value` is writable [[iterator.requirements.general]] to
 `first`.
 *Effects:* Substitutes elements referred by the iterator `i` in the
-range \[`first`, `last`) with `new_value`, when E is `true`.
 *Returns:* `last` for the overloads in namespace `ranges`.
 *Complexity:* Exactly `last - first` applications of the corresponding
 predicate and any projection.
@@ -501,90 +666,150 @@ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
     replace_copy_if(ExecutionPolicy&& exec,
                     ForwardIterator1 first, ForwardIterator1 last,
                     ForwardIterator2 result,
                     Predicate pred, const T& new_value);
-template<input_iterator I, sentinel_for<I> S, class T1, class T2, output_iterator<const T2&> O,
-         class Proj = identity>
   requires indirectly_copyable<I, O> &&
-           indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
   constexpr ranges::replace_copy_result<I, O>
     ranges::replace_copy(I first, S last, O result, const T1& old_value, const T2& new_value,
                          Proj proj = {});
-template<input_range R, class T1, class T2, output_iterator<const T2&> O,
-         class Proj = identity>
   requires indirectly_copyable<iterator_t<R>, O> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
   constexpr ranges::replace_copy_result<borrowed_iterator_t<R>, O>
     ranges::replace_copy(R&& r, O result, const T1& old_value, const T2& new_value,
                          Proj proj = {});
-template<input_iterator I, sentinel_for<I> S, class T, output_iterator<const T&> O,
          class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
-  requires indirectly_copyable<I, O>
   constexpr ranges::replace_copy_if_result<I, O>
     ranges::replace_copy_if(I first, S last, O result, Pred pred, const T& new_value,
                             Proj proj = {});
-template<input_range R, class T, output_iterator<const T&> O, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
-  requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::replace_copy_if_result<borrowed_iterator_t<R>, O>
     ranges::replace_copy_if(R&& r, O result, Pred pred, const T& new_value,
                             Proj proj = {});
 ```
-Let E be
 - `bool(*(first + (i - result)) == old_value)` for `replace_copy`;
 - `bool(pred(*(first + (i - result))))` for `replace_copy_if`;
 - `bool(invoke(proj, *(first + (i - result))) == old_value)` for
   `ranges::replace_copy`;
 - `bool(invoke(pred, invoke(proj, *(first + (i - result)))))` for
   `ranges::replace_copy_if`.
 *Mandates:* The results of the expressions `*first` and `new_value` are
 writable [[iterator.requirements.general]] to `result`.
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) do not overlap.
 *Effects:* Assigns through every iterator `i` in the range \[`result`,
-`result + (last - first)`) a new corresponding value
-- `new_value` if E is `true` or
 - `*(first + (i - result))` otherwise.
 *Returns:*
-- `result + (last - first)` for the overloads in namespace `std`.
-- `{last, result + (last - first)}` for the overloads in namespace
-  `ranges`.
-*Complexity:* Exactly `last - first` applications of the corresponding
-predicate and any projection.
 ### Fill <a id="alg.fill">[[alg.fill]]</a>
 ``` cpp
-template<class ForwardIterator, class T>
   constexpr void fill(ForwardIterator first, ForwardIterator last, const T& value);
-template<class ExecutionPolicy, class ForwardIterator, class T>
   void fill(ExecutionPolicy&& exec,
             ForwardIterator first, ForwardIterator last, const T& value);
-template<class OutputIterator, class Size, class T>
   constexpr OutputIterator fill_n(OutputIterator first, Size n, const T& value);
-template<class ExecutionPolicy, class ForwardIterator, class Size, class T>
   ForwardIterator fill_n(ExecutionPolicy&& exec,
                          ForwardIterator first, Size n, const T& value);
-template<class T, output_iterator<const T&> O, sentinel_for<O> S>
   constexpr O ranges::fill(O first, S last, const T& value);
-template<class T, output_range<const T&> R>
   constexpr borrowed_iterator_t<R> ranges::fill(R&& r, const T& value);
-template<class T, output_iterator<const T&> O>
   constexpr O ranges::fill_n(O first, iter_difference_t<O> n, const T& value);
 ```
 Let N be max(0, `n`) for the `fill_n` algorithms, and `last - first` for
 the `fill` algorithms.
@@ -624,10 +849,21 @@ template<class R, copy_constructible F>
   requires invocable<F&> && output_range<R, invoke_result_t<F&>>
   constexpr borrowed_iterator_t<R> ranges::generate(R&& r, F gen);
 template<input_or_output_iterator O, copy_constructible F>
   requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
   constexpr O ranges::generate_n(O first, iter_difference_t<O> n, F gen);
 ```
 Let N be max(0, `n`) for the `generate_n` algorithms, and `last - first`
 for the `generate` algorithms.
@@ -639,17 +875,21 @@ through each iterator in the range \[`first`, `first + `N).
 *Returns:* `first + `N.
 *Complexity:* Exactly N evaluations of `gen()` and assignments.
 ### Remove <a id="alg.remove">[[alg.remove]]</a>
 ``` cpp
-template<class ForwardIterator, class T>
   constexpr ForwardIterator remove(ForwardIterator first, ForwardIterator last,
                                    const T& value);
-template<class ExecutionPolicy, class ForwardIterator, class T>
   ForwardIterator remove(ExecutionPolicy&& exec,
                          ForwardIterator first, ForwardIterator last,
                          const T& value);
 template<class ForwardIterator, class Predicate>
@@ -658,26 +898,52 @@ template<class ForwardIterator, class Predicate>
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   ForwardIterator remove_if(ExecutionPolicy&& exec,
                             ForwardIterator first, ForwardIterator last,
                             Predicate pred);
-template<permutable I, sentinel_for<I> S, class T, class Proj = identity>
   requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr subrange<I> ranges::remove(I first, S last, const T& value, Proj proj = {});
-template<forward_range R, class T, class Proj = identity>
   requires permutable<iterator_t<R>> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr borrowed_subrange_t<R>
     ranges::remove(R&& r, const T& value, Proj proj = {});
 template<permutable I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr subrange<I> ranges::remove_if(I first, S last, Pred pred, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires permutable<iterator_t<R>>
   constexpr borrowed_subrange_t<R>
     ranges::remove_if(R&& r, Pred pred, Proj proj = {});
 ```
 Let E be
 - `bool(*i == value)` for `remove`;
@@ -706,16 +972,17 @@ predicate and any projection.
 the returned value, has a valid but unspecified state, because the
 algorithms can eliminate elements by moving from elements that were
 originally in that range. — *end note*]
 ``` cpp
-template<class InputIterator, class OutputIterator, class T>
   constexpr OutputIterator
     remove_copy(InputIterator first, InputIterator last,
                 OutputIterator result, const T& value);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
-         class T>
   ForwardIterator2
     remove_copy(ExecutionPolicy&& exec,
                 ForwardIterator1 first, ForwardIterator1 last,
                 ForwardIterator2 result, const T& value);
@@ -728,63 +995,109 @@ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
   ForwardIterator2
     remove_copy_if(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
                    ForwardIterator2 result, Predicate pred);
-template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class T,
-         class Proj = identity>
   requires indirectly_copyable<I, O> &&
            indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr ranges::remove_copy_result<I, O>
     ranges::remove_copy(I first, S last, O result, const T& value, Proj proj = {});
-template<input_range R, weakly_incrementable O, class T, class Proj = identity>
   requires indirectly_copyable<iterator_t<R>, O> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr ranges::remove_copy_result<borrowed_iterator_t<R>, O>
     ranges::remove_copy(R&& r, O result, const T& value, Proj proj = {});
 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
          class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
   requires indirectly_copyable<I, O>
   constexpr ranges::remove_copy_if_result<I, O>
     ranges::remove_copy_if(I first, S last, O result, Pred pred, Proj proj = {});
 template<input_range R, weakly_incrementable O, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::remove_copy_if_result<borrowed_iterator_t<R>, O>
     ranges::remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});
 ```
-Let E be
 - `bool(*i == value)` for `remove_copy`;
 - `bool(pred(*i))` for `remove_copy_if`;
 - `bool(invoke(proj, *i) == value)` for `ranges::remove_copy`;
 - `bool(invoke(pred, invoke(proj, *i)))` for `ranges::remove_copy_if`.
-Let N be the number of elements in \[`first`, `last`) for which E is
-`false`.
 *Mandates:* `*first` is writable [[iterator.requirements.general]] to
 `result`.
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) do not overlap.
-[*Note 2*: For the overloads with an `ExecutionPolicy`, there might be
-a performance cost if `iterator_traits<ForwardIterator1>::value_type`
-does not meet the *Cpp17MoveConstructible*
-([[cpp17.moveconstructible]]) requirements. — *end note*]
-*Effects:* Copies all the elements referred to by the iterator `i` in
-the range \[`first`, `last`) for which E is `false`.
 *Returns:*
 - `result + `N, for the algorithms in namespace `std`.
-- `{last, result + `N`}`, for the algorithms in namespace `ranges`.
-*Complexity:* Exactly `last - first` applications of the corresponding
 predicate and any projection.
 *Remarks:* Stable [[algorithm.stable]].
 ### Unique <a id="alg.unique">[[alg.unique]]</a>
@@ -810,10 +1123,20 @@ template<permutable I, sentinel_for<I> S, class Proj = identity,
 template<forward_range R, class Proj = identity,
          indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
   requires permutable<iterator_t<R>>
   constexpr borrowed_subrange_t<R>
     ranges::unique(R&& r, C comp = {}, Proj proj = {});
 ```
 Let `pred` be `equal_to{}` for the overloads with no parameter `pred`,
 and let E be
@@ -875,52 +1198,83 @@ template<input_range R, weakly_incrementable O, class Proj = identity,
            (forward_iterator<iterator_t<R>> ||
             (input_iterator<O> && same_as<range_value_t<R>, iter_value_t<O>>) ||
             indirectly_copyable_storable<iterator_t<R>, O>)
   constexpr ranges::unique_copy_result<borrowed_iterator_t<R>, O>
     ranges::unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
 ```
 Let `pred` be `equal_to{}` for the overloads in namespace `std` with no
-parameter `pred`, and let E be
 - `bool(pred(*i, *(i - 1)))` for the overloads in namespace `std`;
 - `bool(invoke(comp, invoke(proj, *i), invoke(proj, *(i - 1))))` for the
   overloads in namespace `ranges`.
 *Mandates:* `*first` is writable [[iterator.requirements.general]] to
 `result`.
 *Preconditions:*
-- The ranges \[`first`, `last`) and \[`result`, `result+(last-first)`)
- do not overlap.
 - For the overloads in namespace `std`:
   - The comparison function is an equivalence relation.
   - For the overloads with no `ExecutionPolicy`, let `T` be the value
     type of `InputIterator`. If `InputIterator` models
     `forward_iterator` [[iterator.concept.forward]], then there are no
     additional requirements for `T`. Otherwise, if `OutputIterator`
     meets the *Cpp17ForwardIterator* requirements and its value type is
     the same as `T`, then `T` meets the *Cpp17CopyAssignable*
     ([[cpp17.copyassignable]]) requirements. Otherwise, `T` meets both
     the *Cpp17CopyConstructible* ([[cpp17.copyconstructible]]) and
-    *Cpp17CopyAssignable* requirements. \[*Note 1*: For the overloads
-    with an `ExecutionPolicy`, there might be a performance cost if the
-    value type of `ForwardIterator1` does not meet both the
-    *Cpp17CopyConstructible* and *Cpp17CopyAssignable*
-    requirements. — *end note*]
-*Effects:* Copies only the first element from every consecutive group of
-equal elements referred to by the iterator `i` in the range \[`first`,
-`last`) for which E holds.
 *Returns:*
 - `result + `N for the overloads in namespace `std`.
-- `{last, result + `N`}` for the overloads in namespace `ranges`.
-*Complexity:* Exactly `last - first - 1` applications of the
 corresponding predicate and no more than twice as many applications of
 any projection.
 ### Reverse <a id="alg.reverse">[[alg.reverse]]</a>
@@ -935,10 +1289,17 @@ template<bidirectional_iterator I, sentinel_for<I> S>
   requires permutable<I>
   constexpr I ranges::reverse(I first, S last);
 template<bidirectional_range R>
   requires permutable<iterator_t<R>>
   constexpr borrowed_iterator_t<R> ranges::reverse(R&& r);
 ```
 *Preconditions:* For the overloads in namespace `std`,
 `BidirectionalIterator` meets the *Cpp17ValueSwappable*
 requirements [[swappable.requirements]].
@@ -988,10 +1349,38 @@ following assignment takes place:
 - `result + `N for the overloads in namespace `std`.
 - `{last, result + `N`}` for the overloads in namespace `ranges`.
 *Complexity:* Exactly N assignments.
 ### Rotate <a id="alg.rotate">[[alg.rotate]]</a>
 ``` cpp
 template<class ForwardIterator>
   constexpr ForwardIterator
@@ -1001,10 +1390,13 @@ template<class ExecutionPolicy, class ForwardIterator>
     rotate(ExecutionPolicy&& exec,
            ForwardIterator first, ForwardIterator middle, ForwardIterator last);
 template<permutable I, sentinel_for<I> S>
   constexpr subrange<I> ranges::rotate(I first, I middle, S last);
 ```
 *Preconditions:* \[`first`, `middle`) and \[`middle`, `last`) are valid
 ranges. For the overloads in namespace `std`, `ForwardIterator` meets
 the *Cpp17ValueSwappable* requirements [[swappable.requirements]], and
@@ -1033,10 +1425,22 @@ template<forward_range R>
 ```
 *Effects:* Equivalent to:
 `return ranges::rotate(ranges::begin(r), middle, ranges::end(r));`
 ``` cpp
 template<class ForwardIterator, class OutputIterator>
   constexpr OutputIterator
     rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last,
                 OutputIterator result);
@@ -1068,10 +1472,38 @@ following assignment takes place:
 - `result + `N for the overloads in namespace `std`.
 - `{last, result + `N`}` for the overload in namespace `ranges`.
 *Complexity:* Exactly N assignments.
 ``` cpp
 template<forward_range R, weakly_incrementable O>
   requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::rotate_copy_result<borrowed_iterator_t<R>, O>
     ranges::rotate_copy(R&& r, iterator_t<R> middle, O result);
@@ -1081,10 +1513,24 @@ template<forward_range R, weakly_incrementable O>
 ``` cpp
 return ranges::rotate_copy(ranges::begin(r), middle, ranges::end(r), std::move(result));
 ```
 ### Sample <a id="alg.random.sample">[[alg.random.sample]]</a>
 ``` cpp
 template<class PopulationIterator, class SampleIterator,
          class Distance, class UniformRandomBitGenerator>
@@ -1193,26 +1639,34 @@ template<class ExecutionPolicy, class ForwardIterator>
 template<permutable I, sentinel_for<I> S>
   constexpr subrange<I> ranges::shift_left(I first, S last, iter_difference_t<I> n);
 template<forward_range R>
   requires permutable<iterator_t<R>>
-  constexpr borrowed_subrange_t<R> ranges::shift_left(R&& r, range_difference_t<R> n)
 ```
 *Preconditions:* `n >= 0` is `true`. For the overloads in namespace
 `std`, the type of `*first` meets the *Cpp17MoveAssignable*
 requirements.
 *Effects:* If `n == 0` or `n >= last - first`, does nothing. Otherwise,
 moves the element from position `first + n + i` into position
 `first + i` for each non-negative integer `i < (last - first) - n`. For
-the overloads without an `ExecutionPolicy` template parameter, does so
-in order starting from `i = 0` and proceeding to
-`i = (last - first) - n - 1`.
 *Returns:* Let *NEW_LAST* be `first + (last - first - n)` if
-`n < last - first`, otherwise `first`.
 - *NEW_LAST* for the overloads in namespace `std`.
 - `{first, `*`NEW_LAST`*`}` for the overloads in namespace `ranges`.
 *Complexity:* At most `(last - first) - n` assignments.
@@ -1230,10 +1684,19 @@ template<class ExecutionPolicy, class ForwardIterator>
 template<permutable I, sentinel_for<I> S>
   constexpr subrange<I> ranges::shift_right(I first, S last, iter_difference_t<I> n);
 template<forward_range R>
   requires permutable<iterator_t<R>>
   constexpr borrowed_subrange_t<R> ranges::shift_right(R&& r, range_difference_t<R> n);
 ```
 *Preconditions:* `n >= 0` is `true`. For the overloads in namespace
 `std`, the type of `*first` meets the *Cpp17MoveAssignable*
 requirements, and `ForwardIterator` meets the
@@ -1242,20 +1705,19 @@ the *Cpp17ValueSwappable* requirements.
 *Effects:* If `n == 0` or `n >= last - first`, does nothing. Otherwise,
 moves the element from position `first + i` into position
 `first + n + i` for each non-negative integer `i < (last - first) - n`.
 Does so in order starting from `i = (last - first) - n - 1` and
-proceeding to `i = 0` if:
-- for the overload in namespace `std` without an `ExecutionPolicy`
- template parameter, `ForwardIterator` meets the
-  *Cpp17BidirectionalIterator* requirements,
-- for the overloads in namespace `ranges`, `I` models
-  `bidirectional_iterator`.
 *Returns:* Let *NEW_FIRST* be `first + n` if `n < last - first`,
-otherwise `last`.
 - *NEW_FIRST* for the overloads in namespace `std`.
 - `{`*`NEW_FIRST`*`, last}` for the overloads in namespace `ranges`.
 *Complexity:* At most `(last - first) - n` assignments or swaps.

 *Complexity:* Exactly N assignments.
 ``` cpp
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
+  ForwardIterator2 copy(ExecutionPolicy&& exec,
                         ForwardIterator1 first, ForwardIterator1 last,
                         ForwardIterator2 result);
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS>
+  requires indirectly_copyable<I, O>
+  ranges::copy_result<I, O>
+    ranges::copy(Ep&& exec, I first, S last, O result, OutS result_last);
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+  ranges::copy_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::copy(Ep&& exec, R&& r, OutR&& result_r);
 ```
+Let `result_last` be `result + (last - first)` for the overload in
+namespace `std`.
+Let N be min(`last - first`,  `result_last - result`).
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
+`result + `N) do not overlap.
+*Effects:* Copies elements in the range \[`first`, `first + `N) into the
+range \[`result`, `result + `N). For each non-negative integer n < N,
+performs `*(result + `n`) = *(first + `n`)`.
+*Returns:*
+- `result + `N for the overload in namespace `std`.
+- `{first + `N`, result + `N`}` for the overloads in namespace `ranges`.
+*Complexity:* Exactly N assignments.
 ``` cpp
 template<class InputIterator, class Size, class OutputIterator>
   constexpr OutputIterator copy_n(InputIterator first, Size n,
                                   OutputIterator result);
 template<input_iterator I, weakly_incrementable O>
   requires indirectly_copyable<I, O>
   constexpr ranges::copy_n_result<I, O>
     ranges::copy_n(I first, iter_difference_t<I> n, O result);
+template<execution-policy Ep, random_access_iterator I, random_access_iterator O,
+         sized_sentinel_for<O> OutS>
+  requires indirectly_copyable<I, O>
+  ranges::copy_n_result<I, O>
+    ranges::copy_n(Ep&& exec, I first, iter_difference_t<I> n, O result, OutS result_last);
 ```
+Let M be max(0, `n`).
+Let `result_last` be `result + `M for the overloads with no parameter
+`result_last`.
+Let N be min(`result_last - result`, M).
 *Mandates:* The type `Size` is convertible to an integral
 type [[conv.integral]], [[class.conv]].
 *Effects:* For each non-negative integer i < N, performs
 template<input_range R, weakly_incrementable O, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::copy_if_result<borrowed_iterator_t<R>, O>
     ranges::copy_if(R&& r, O result, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+          random_access_iterator O, sized_sentinel_for<O> OutS,
+          class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_copyable<I, O>
+  ranges::copy_if_result<I, O>
+    ranges::copy_if(Ep&& exec, I first, S last, O result, OutS result_last,
+                    Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+          class Proj = identity,
+          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+  ranges::copy_if_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::copy_if(Ep&& exec, R&& r, OutR&& result_r, Pred pred, Proj proj = {});
 ```
+Let E(`i`) be:
 - `bool(pred(*i))` for the overloads in namespace `std`;
 - `bool(invoke(pred, invoke(proj, *i)))` for the overloads in namespace
+  `ranges`.
+Let:
+- M be the number of iterators `i` in the range \[`first`, `last`) for
+  which the condition E(`i`) holds;
+- `result_last` be `result + `M for the overloads with no parameter
+  `result_last` or `result_r`;
+- N be min(M,  `result_last - result`).
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
+`result + `N) do not overlap.
+[*Note 1*: For the parallel algorithm overload in namespace `std`,
+there can be a performance cost if
+`iterator_traits<ForwardIterator1>::value_type` does not meet the
+*Cpp17MoveConstructible* ([[cpp17.moveconstructible]]) requirements.
+For the parallel algorithm overloads in namespace `ranges`, there can be
+a performance cost if `iter_value_t<I>` does not model
+`move_constructible`. — *end note*]
+*Effects:* Copies the first N elements referred to by the iterator `i`
+in the range \[`first`, `last`) for which E(`i`) is `true` into the
+range \[`result`, `result + `N).
 *Returns:*
 - `result + `N for the overloads in namespace `std`.
+- `{last, result + `N`}` for the overloads in namespace `ranges`, if N
+  is equal to M.
+- Otherwise, `{j, result_last}` for the overloads in namespace `ranges`,
+  where `j` is the iterator in \[`first`, `last`) for which E(`j`) holds
+  and there are exactly N iterators `i` in \[`first`, `j`) for which
+  E(`i`) holds.
+*Complexity:* At most `last - first` applications of the corresponding
 predicate and any projection.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
   requires indirectly_movable<iterator_t<R>, O>
   constexpr ranges::move_result<borrowed_iterator_t<R>, O>
     ranges::move(R&& r, O result);
 ```
+Let E(n) be
 - `std::move(*(first + `n`))` for the overload in namespace `std`;
 - `ranges::iter_move(first + `n`)` for the overloads in namespace
   `ranges`.
 *Preconditions:* `result` is not in the range \[`first`, `last`).
 *Effects:* Moves elements in the range \[`first`, `last`) into the range
 \[`result`, `result + `N) starting from `first` and proceeding to
 `last`. For each non-negative integer n < N, performs
+`*(result + `n`) = `E(n).
 *Returns:*
 - `result + `N for the overload in namespace `std`.
 - `{last, result + `N`}` for the overloads in namespace `ranges`.
 *Complexity:* Exactly N assignments.
 ``` cpp
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
+  ForwardIterator2 move(ExecutionPolicy&& exec,
                         ForwardIterator1 first, ForwardIterator1 last,
                         ForwardIterator2 result);
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS>
+  requires indirectly_movable<I, O>
+  ranges::move_result<I, O>
+    ranges::move(Ep&& exec, I first, S last, O result, OutS result_last);
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR>
+  requires indirectly_movable<iterator_t<R>, iterator_t<OutR>>
+  ranges::move_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::move(Ep&& exec, R&& r, OutR&& result_r);
 ```
+Let E(n) be:
+- `std::move(*(first + `n`))` for the overload in namespace `std`;
+- `ranges::iter_move(first + `n`)` for the overloads in namespace
+  `ranges`.
+Let `result_last` be `result + (last - first)` for the overloads in
+namespace `std`.
+Let N be min(`last - first`,  `result_last - result`).
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
 `result + `N) do not overlap.
+*Effects:* Moves elements in the range \[`first`, `first + `N) into the
+range \[`result`, `result + `N). For each non-negative integer n < N,
+performs `*(result + `n`) = `E(n).
+*Returns:*
+- `result + `N for the overload in namespace `std`.
+- `{first + `N`, result + `N`}` for the overloads in namespace `ranges`.
 *Complexity:* Exactly N assignments.
 ``` cpp
 template<class BidirectionalIterator1, class BidirectionalIterator2>
   requires indirectly_movable<iterator_t<R>, I>
   constexpr ranges::move_backward_result<borrowed_iterator_t<R>, I>
     ranges::move_backward(R&& r, I result);
 ```
+Let E(n) be
 - `std::move(*(last - `n`))` for the overload in namespace `std`;
 - `ranges::iter_move(last - `n`)` for the overloads in namespace
   `ranges`.
 *Effects:* Moves elements in the range \[`first`, `last`) into the range
 \[`result - `N, `result`) starting from `last - 1` and proceeding to
 `first`.[^3]
+For each positive integer n ≤ N, performs `*(result - `n`) = `E(n).
 *Returns:*
 - `result - `N for the overload in namespace `std`.
 - `{last, result - `N`}` for the overloads in namespace `ranges`.
     ranges::swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
 template<input_range R1, input_range R2>
   requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
   constexpr ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
     ranges::swap_ranges(R1&& r1, R2&& r2);
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2>
+  requires indirectly_swappable<I1, I2>
+  ranges::swap_ranges_result<I1, I2>
+    ranges::swap_ranges(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2);
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2>
+  requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
+  ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
+    ranges::swap_ranges(Ep&& exec, R1&& r1, R2&& r2);
 ```
 Let:
+- `last2` be `first2 + (last1 - first1)` for the overloads in namespace
+ `std` with no parameter named `last2`;
 - M be min(`last1 - first1`,  `last2 - first2`).
 *Preconditions:* The two ranges \[`first1`, `last1`) and \[`first2`,
 `last2`) do not overlap. For the overloads in namespace `std`,
 `*(first1 + `n`)` is swappable with [[swappable.requirements]]
 template<input_range R, weakly_incrementable O, copy_constructible F,
          class Proj = identity>
   requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
   constexpr ranges::unary_transform_result<borrowed_iterator_t<R>, O>
     ranges::transform(R&& r, O result, F op, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS,
+         copy_constructible F, class Proj = identity>
+  requires indirectly_writable<O, indirect_result_t<F&, projected<I, Proj>>>
+  ranges::unary_transform_result<I, O>
+    ranges::transform(Ep&& exec, I first1, S last1, O result, OutS result_last,
+                      F op, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+          copy_constructible F, class Proj = identity>
+  requires indirectly_writable<iterator_t<OutR>,
+                                indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
+  ranges::unary_transform_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::transform(Ep&& exec, R&& r, OutR&& result_r, F op, Proj proj = {});
 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
          weakly_incrementable O, copy_constructible F, class Proj1 = identity,
          class Proj2 = identity>
   requires indirectly_writable<O, indirect_result_t<F&, projected<I1, Proj1>,
                                projected<I2, Proj2>>>
   requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
                                projected<iterator_t<R2>, Proj2>>>
   constexpr ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
     ranges::transform(R1&& r1, R2&& r2, O result,
                       F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         random_access_iterator O, sized_sentinel_for<O> OutS,
+         copy_constructible F, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_writable<O, indirect_result_t<F&, projected<I1, Proj1>,
+                                projected<I2, Proj2>>>
+  ranges::binary_transform_result<I1, I2, O>
+    ranges::transform(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                      O result, OutS result_last,
+                      F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         sized-random-access-range OutR, copy_constructible F,
+          class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_writable<iterator_t<OutR>,
+                                indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
+                                projected<iterator_t<R2>, Proj2>>>
+  ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>,
+                                  borrowed_iterator_t<OutR>>
+    ranges::transform(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r,
+                      F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let:
+- `last2` be `first2 + (last1 - first1)` for the overloads in namespace
+ `std` with parameter `first2` but no parameter `last2`;
+- M be `last1 - first1` for unary transforms, or
   min(`last1 - first1`,  `last2 - first2`) for binary transforms;
+- `result_last` be `result + `M for the overloads with no parameter
+  `result_last` or `result_r`;
+- N be min(M,  `result_last - result`);
+- E(`i`) be
   - `op(*(first1 + (i - result)))` for unary transforms defined in
     namespace `std`;
   - `binary_op(*(first1 + (i - result)), *(first2 + (i - result)))` for
     binary transforms defined in namespace `std`;
   - `invoke(op, invoke(proj, *(first1 + (i - result))))` for unary
     transforms defined in namespace `ranges`;
   - `invoke(binary_op, invoke(proj1, *(first1 + (i - result))), invoke(proj2,*(first2 + (i - result))))`
     for binary transforms defined in namespace `ranges`.
+*Preconditions:* For parallel algorithm overloads `op` and `binary_op`
+satisfy the requirements specified in [[algorithms.parallel.user]]. `op`
+and `binary_op` do not invalidate iterators or subranges, nor modify
+elements in the ranges
 - \[`first1`, `first1 + `N\],
 - \[`first2`, `first2 + `N\], and
 - \[`result`, `result + `N\].[^4]
 *Effects:* Assigns through every iterator `i` in the range \[`result`,
+`result + `N) a new corresponding value equal to E(`i`).
 *Returns:*
 - `result + `N for the overloads defined in namespace `std`.
 - `{first1 + `N`, result + `N`}` for unary transforms defined in
   namespace `ranges`.
 - `{first1 + `N`, first2 + `N`, result + `N`}` for binary transforms
   defined in namespace `ranges`.
 *Complexity:* Exactly N applications of `op` or `binary_op`, and any
+projections. This requirement also applies to the parallel algorithm
+overloads.
 *Remarks:* `result` may be equal to `first1` or `first2`.
 ### Replace <a id="alg.replace">[[alg.replace]]</a>
 ``` cpp
+template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
   constexpr void replace(ForwardIterator first, ForwardIterator last,
                          const T& old_value, const T& new_value);
+template<class ExecutionPolicy, class ForwardIterator,
+         class T = iterator_traits<ForwardIterator>::value_type>
   void replace(ExecutionPolicy&& exec,
                ForwardIterator first, ForwardIterator last,
                const T& old_value, const T& new_value);
+template<class ForwardIterator, class Predicate,
+         class T = iterator_traits<ForwardIterator>::value_type>
   constexpr void replace_if(ForwardIterator first, ForwardIterator last,
                             Predicate pred, const T& new_value);
+template<class ExecutionPolicy, class ForwardIterator, class Predicate,
+         class T = iterator_traits<ForwardIterator>::value_type>
   void replace_if(ExecutionPolicy&& exec,
                   ForwardIterator first, ForwardIterator last,
                   Predicate pred, const T& new_value);
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         class T1 = projected_value_t<I, Proj>, class T2 = T1>
   requires indirectly_writable<I, const T2&> &&
            indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
   constexpr I
     ranges::replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});
+template<input_range R, class Proj = identity,
+         class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = T1>
   requires indirectly_writable<iterator_t<R>, const T2&> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
   constexpr borrowed_iterator_t<R>
     ranges::replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, class T1 = projected_value_t<I, Proj>, class T2 = T1>
+  requires indirectly_writable<I, const T2&> &&
+           indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
+  I ranges::replace(Ep&& exec, I first, S last,
+                    const T1& old_value, const T2& new_value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = T1>
+  requires indirectly_writable<iterator_t<R>, const T2&> &&
+            indirect_binary_predicate<ranges::equal_to,
+                                      projected<iterator_t<R>, Proj>, const T1*>
+  borrowed_iterator_t<R>
+    ranges::replace(Ep&& exec, R&& r, const T1& old_value, const T2& new_value,
+                    Proj proj = {});
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         class T = projected_value_t<I, Proj>,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   requires indirectly_writable<I, const T&>
   constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
+template<input_range R, class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires indirectly_writable<iterator_t<R>, const T&>
   constexpr borrowed_iterator_t<R>
     ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, class T = projected_value_t<I, Proj>,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_writable<I, const T&>
+  I ranges::replace_if(Ep&& exec, I first, S last, Pred pred,
+                       const T& new_value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_writable<iterator_t<R>, const T&>
+  borrowed_iterator_t<R>
+    ranges::replace_if(Ep&& exec, R&& r, Pred pred, const T& new_value, Proj proj = {});
 ```
+Let E(`i`) be
 - `bool(*i == old_value)` for `replace`;
 - `bool(pred(*i))` for `replace_if`;
 - `bool(invoke(proj, *i) == old_value)` for `ranges::replace`;
 - `bool(invoke(pred, invoke(proj, *i)))` for `ranges::replace_if`.
 *Mandates:* `new_value` is writable [[iterator.requirements.general]] to
 `first`.
 *Effects:* Substitutes elements referred by the iterator `i` in the
+range \[`first`, `last`) with `new_value`, when E(`i`) is `true`.
 *Returns:* `last` for the overloads in namespace `ranges`.
 *Complexity:* Exactly `last - first` applications of the corresponding
 predicate and any projection.
     replace_copy_if(ExecutionPolicy&& exec,
                     ForwardIterator1 first, ForwardIterator1 last,
                     ForwardIterator2 result,
                     Predicate pred, const T& new_value);
+template<input_iterator I, sentinel_for<I> S, class O,
+         class Proj = identity, class T1 = projected_value_t<I, Proj>, class T2 = iter_value_t<O>>
   requires indirectly_copyable<I, O> &&
+           indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*> &&
+           output_iterator<O, const T2&>
   constexpr ranges::replace_copy_result<I, O>
     ranges::replace_copy(I first, S last, O result, const T1& old_value, const T2& new_value,
                          Proj proj = {});
+template<input_range R, class O, class Proj = identity,
+         class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = iter_value_t<O>>
   requires indirectly_copyable<iterator_t<R>, O> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
+           && output_iterator<O, const T2&>
   constexpr ranges::replace_copy_result<borrowed_iterator_t<R>, O>
     ranges::replace_copy(R&& r, O result, const T1& old_value, const T2& new_value,
                          Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS,
+         class Proj = identity,
+         class T1 = projected_value_t<I, Proj>, class T2 = iter_value_t<O>>
+  requires indirectly_copyable<I, O> &&
+           indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*> &&
+           indirectly_writable<O, const T2&>
+  ranges::replace_copy_result<I, O>
+    ranges::replace_copy(Ep&& exec, I first, S last, O result, OutS result_last,
+                         const T1& old_value, const T2& new_value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+         class Proj = identity, class T1 = projected_value_t<iterator_t<R>, Proj>,
+         class T2 = range_value_t<OutR>>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>> &&
+           indirect_binary_predicate<ranges::equal_to,
+                                      projected<iterator_t<R>, Proj>, const T1*> &&
+           indirectly_writable<iterator_t<OutR>, const T2&>
+  ranges::replace_copy_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::replace_copy(Ep&& exec, R&& r, OutR&& result_r, const T1& old_value,
+                         const T2& new_value, Proj proj = {});
+template<input_iterator I, sentinel_for<I> S,class O, class T = iter_value_t<O>,
          class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_copyable<I, O> && output_iterator<O, const T&>
   constexpr ranges::replace_copy_if_result<I, O>
     ranges::replace_copy_if(I first, S last, O result, Pred pred, const T& new_value,
                             Proj proj = {});
+template<input_range R, class O, class T = iter_value_t<O>, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_copyable<iterator_t<R>, O> && output_iterator<O, const T&>
   constexpr ranges::replace_copy_if_result<borrowed_iterator_t<R>, O>
     ranges::replace_copy_if(R&& r, O result, Pred pred, const T& new_value,
                             Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS, class T = iter_value_t<O>,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_copyable<I, O> && indirectly_writable<O, const T&>
+  ranges::replace_copy_if_result<I, O>
+    ranges::replace_copy_if(Ep&& exec, I first, S last, O result, OutS result_last,
+                            Pred pred, const T& new_value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+         class T = range_value_t<OutR>, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>> &&
+           indirectly_writable<OutR, const T&>
+  ranges::replace_copy_if_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::replace_copy_if(Ep&& exec, R&& r, OutR&& result_r, Pred pred, const T& new_value,
+                            Proj proj = {});
 ```
+Let E(`i`) be
 - `bool(*(first + (i - result)) == old_value)` for `replace_copy`;
 - `bool(pred(*(first + (i - result))))` for `replace_copy_if`;
 - `bool(invoke(proj, *(first + (i - result))) == old_value)` for
   `ranges::replace_copy`;
 - `bool(invoke(pred, invoke(proj, *(first + (i - result)))))` for
   `ranges::replace_copy_if`.
+Let:
+- `result_last` be `result + (last - first)` for the overloads with no
+  parameter `result_last` or `result_r`;
+- N be min(`last - first`,  `result_last - result`).
 *Mandates:* The results of the expressions `*first` and `new_value` are
 writable [[iterator.requirements.general]] to `result`.
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
+`result + `N) do not overlap.
 *Effects:* Assigns through every iterator `i` in the range \[`result`,
+`result + `N) a new corresponding value
+- `new_value` if E(`i`) is `true` or
 - `*(first + (i - result))` otherwise.
 *Returns:*
+- `result + `N for the overloads in namespace `std`.
+- `{first + `N`, result + `N`}` for the overloads in namespace `ranges`.
+*Complexity:* Exactly N applications of the corresponding predicate and
+any projection.
 ### Fill <a id="alg.fill">[[alg.fill]]</a>
 ``` cpp
+template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
   constexpr void fill(ForwardIterator first, ForwardIterator last, const T& value);
+template<class ExecutionPolicy, class ForwardIterator,
+         class T = iterator_traits<ForwardIterator>::value_type>
   void fill(ExecutionPolicy&& exec,
             ForwardIterator first, ForwardIterator last, const T& value);
+template<class OutputIterator, class Size, class T = iterator_traits<OutputIterator>::value_type>
   constexpr OutputIterator fill_n(OutputIterator first, Size n, const T& value);
+template<class ExecutionPolicy, class ForwardIterator, class Size,
+         class T = iterator_traits<ForwardIterator>::value_type>
   ForwardIterator fill_n(ExecutionPolicy&& exec,
                          ForwardIterator first, Size n, const T& value);
+template<class O, sentinel_for<O> S, class T = iter_value_t<O>>
+  requires output_iterator<O, const T&>
   constexpr O ranges::fill(O first, S last, const T& value);
+template<class R, class T = range_value_t<R>>
+  requires output_range<R, const T&>
   constexpr borrowed_iterator_t<R> ranges::fill(R&& r, const T& value);
+template<class O, class T = iter_value_t<O>>
+  requires output_iterator<O, const T&>
   constexpr O ranges::fill_n(O first, iter_difference_t<O> n, const T& value);
+template<execution-policy Ep, random_access_iterator O, sized_sentinel_for<O> S,
+         class T = iter_value_t<O>>
+  requires indirectly_writable<O, const T&>
+  O ranges::fill(Ep&& exec, O first, S last, const T& value);
+template<execution-policy Ep, sized-random-access-range R, class T = range_value_t<R>>
+  requires indirectly_writable<iterator_t<R>, const T&>
+  borrowed_iterator_t<R> fill(Ep&& exec, R&& r, const T& value);
+template<execution-policy Ep, random_access_iterator O, class T = iter_value_t<O>>
+  requires indirectly_writable<O, const T&>
+  O ranges::fill_n(Ep&& exec, O first, iter_difference_t<O> n, const T& value);
 ```
 Let N be max(0, `n`) for the `fill_n` algorithms, and `last - first` for
 the `fill` algorithms.
   requires invocable<F&> && output_range<R, invoke_result_t<F&>>
   constexpr borrowed_iterator_t<R> ranges::generate(R&& r, F gen);
 template<input_or_output_iterator O, copy_constructible F>
   requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
   constexpr O ranges::generate_n(O first, iter_difference_t<O> n, F gen);
+template<execution-policy Ep, random_access_iterator O, sized_sentinel_for<O> S,
+         copy_constructible F>
+  requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
+  O ranges::generate(Ep&& exec, O first, S last, F gen);
+template<execution-policy Ep, sized-random-access-range R, copy_constructible F>
+  requires invocable<F&> && indirectly_writable<iterator_t<R>, invoke_result_t<F&>>
+  borrowed_iterator_t<R> ranges::generate(Ep&& exec, R&& r, F gen);
+template<execution-policy Ep, random_access_iterator O, copy_constructible F>
+  requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
+  O ranges::generate_n(Ep&& exec, O first, iter_difference_t<O> n, F gen);
 ```
 Let N be max(0, `n`) for the `generate_n` algorithms, and `last - first`
 for the `generate` algorithms.
 *Returns:* `first + `N.
 *Complexity:* Exactly N evaluations of `gen()` and assignments.
+*Remarks:* `gen` may modify objects via its arguments for parallel
+algorithm overloads [[algorithms.parallel.user]].
 ### Remove <a id="alg.remove">[[alg.remove]]</a>
 ``` cpp
+template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
   constexpr ForwardIterator remove(ForwardIterator first, ForwardIterator last,
                                    const T& value);
+template<class ExecutionPolicy, class ForwardIterator,
+         class T = iterator_traits<ForwardIterator>::value_type>
   ForwardIterator remove(ExecutionPolicy&& exec,
                          ForwardIterator first, ForwardIterator last,
                          const T& value);
 template<class ForwardIterator, class Predicate>
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   ForwardIterator remove_if(ExecutionPolicy&& exec,
                             ForwardIterator first, ForwardIterator last,
                             Predicate pred);
+template<permutable I, sentinel_for<I> S, class Proj = identity,
+         class T = projected_value_t<I, Proj>>
   requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr subrange<I> ranges::remove(I first, S last, const T& value, Proj proj = {});
+template<forward_range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>>
   requires permutable<iterator_t<R>> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr borrowed_subrange_t<R>
     ranges::remove(R&& r, const T& value, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, class T = projected_value_t<I, Proj>>
+  requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+  subrange<I>
+    ranges::remove(Ep&& exec, I first, S last, const T& value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>>
+  requires permutable<iterator_t<R>> &&
+           indirect_binary_predicate<ranges::equal_to,
+                                      projected<iterator_t<R>, Proj>, const T*>
+  borrowed_subrange_t<R>
+    ranges::remove(Ep&& exec, R&& r, const T& value, Proj proj = {});
 template<permutable I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr subrange<I> ranges::remove_if(I first, S last, Pred pred, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires permutable<iterator_t<R>>
   constexpr borrowed_subrange_t<R>
     ranges::remove_if(R&& r, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  subrange<I>
+    ranges::remove_if(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires permutable<iterator_t<R>>
+  borrowed_subrange_t<R>
+    ranges::remove_if(Ep&& exec, R&& r, Pred pred, Proj proj = {});
 ```
 Let E be
 - `bool(*i == value)` for `remove`;
 the returned value, has a valid but unspecified state, because the
 algorithms can eliminate elements by moving from elements that were
 originally in that range. — *end note*]
 ``` cpp
+template<class InputIterator, class OutputIterator,
+         class T = iterator_traits<InputIterator>::value_type>
   constexpr OutputIterator
     remove_copy(InputIterator first, InputIterator last,
                 OutputIterator result, const T& value);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
+         class T = iterator_traits<ForwardIterator1>::value_type>
   ForwardIterator2
     remove_copy(ExecutionPolicy&& exec,
                 ForwardIterator1 first, ForwardIterator1 last,
                 ForwardIterator2 result, const T& value);
   ForwardIterator2
     remove_copy_if(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
                    ForwardIterator2 result, Predicate pred);
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
+         class Proj = identity, class T = projected_value_t<I, Proj>>
   requires indirectly_copyable<I, O> &&
            indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr ranges::remove_copy_result<I, O>
     ranges::remove_copy(I first, S last, O result, const T& value, Proj proj = {});
+template<input_range R, weakly_incrementable O, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>>
   requires indirectly_copyable<iterator_t<R>, O> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr ranges::remove_copy_result<borrowed_iterator_t<R>, O>
     ranges::remove_copy(R&& r, O result, const T& value, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS,
+         class Proj = identity, class T = projected_value_t<I, Proj>>
+  requires indirectly_copyable<I, O> &&
+           indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+  ranges::remove_copy_result<I, O>
+    ranges::remove_copy(Ep&& exec, I first, S last, O result, OutS result_last,
+                        const T& value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+         class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>> &&
+           indirect_binary_predicate<ranges::equal_to,
+                                      projected<iterator_t<R>, Proj>, const T*>
+  ranges::remove_copy_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::remove_copy(Ep&& exec, R&& r, OutR&& result_r, const T& value, Proj proj = {});
 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
          class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
   requires indirectly_copyable<I, O>
   constexpr ranges::remove_copy_if_result<I, O>
     ranges::remove_copy_if(I first, S last, O result, Pred pred, Proj proj = {});
 template<input_range R, weakly_incrementable O, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::remove_copy_if_result<borrowed_iterator_t<R>, O>
     ranges::remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_copyable<I, O>
+  ranges::remove_copy_if_result<I, O>
+    ranges::remove_copy_if(Ep&& exec, I first, S last, O result, OutS result_last,
+                           Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+         class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+  ranges::remove_copy_if_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::remove_copy_if(Ep&& exec, R&& r, OutR&& result_r, Pred pred, Proj proj = {});
 ```
+Let E(`i`) be
 - `bool(*i == value)` for `remove_copy`;
 - `bool(pred(*i))` for `remove_copy_if`;
 - `bool(invoke(proj, *i) == value)` for `ranges::remove_copy`;
 - `bool(invoke(pred, invoke(proj, *i)))` for `ranges::remove_copy_if`.
+Let:
+- M be the number of iterators `i` in \[`first`, `last`) for which
+  E(`i`) is `false`;
+- `result_last` be `result + `M for the overloads with no parameter
+  `result_last` or `result_r`;
+- N be min(M,  `result_last - result`).
 *Mandates:* `*first` is writable [[iterator.requirements.general]] to
 `result`.
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
+`result + `N) do not overlap.
+[*Note 2*: For the parallel algorithm overloads in namespace `std`,
+there can be a performance cost if
+`iterator_traits<ForwardIterator1>::value_type` does not meet the
+*Cpp17MoveConstructible* ([[cpp17.moveconstructible]]) requirements.
+For the parallel algorithm overloads in namespace `ranges`, there can be
+a performance cost if `iter_value_t<I>` does not model
+`move_constructible`. — *end note*]
+*Effects:* Copies the first N elements referred to by the iterator `i`
+in the range \[`first`, `last`) for which E(`i`) is `false` into the
+range \[`result`, `result + `N).
 *Returns:*
 - `result + `N, for the algorithms in namespace `std`.
+- `{last, result + `N`}`, for the algorithms in namespace `ranges`, if N
+  is equal to M.
+- Otherwise, `{j, result_last}`, for the algorithms in namespace
+  `ranges`, where `j` is the iterator in \[`first`, `last`) for which
+  E(`j`) is `false` and there are exactly N iterators `i` in \[`first`,
+  `j`) for which E(`i`) is `false`.
+*Complexity:* At most `last - first` applications of the corresponding
 predicate and any projection.
 *Remarks:* Stable [[algorithm.stable]].
 ### Unique <a id="alg.unique">[[alg.unique]]</a>
 template<forward_range R, class Proj = identity,
          indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
   requires permutable<iterator_t<R>>
   constexpr borrowed_subrange_t<R>
     ranges::unique(R&& r, C comp = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity,
+         indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
+  requires permutable<I>
+  subrange<I> ranges::unique(Ep&& exec, I first, S last, C comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
+  requires permutable<iterator_t<R>>
+  borrowed_subrange_t<R> ranges::unique(Ep&& exec, R&& r, C comp = {}, Proj proj = {});
 ```
 Let `pred` be `equal_to{}` for the overloads with no parameter `pred`,
 and let E be
            (forward_iterator<iterator_t<R>> ||
             (input_iterator<O> && same_as<range_value_t<R>, iter_value_t<O>>) ||
             indirectly_copyable_storable<iterator_t<R>, O>)
   constexpr ranges::unique_copy_result<borrowed_iterator_t<R>, O>
     ranges::unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS, class Proj = identity,
+         indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
+  requires indirectly_copyable<I, O>
+  ranges::unique_copy_result<I, O>
+    ranges::unique_copy(Ep&& exec, I first, S last, O result, OutS result_last,
+                        C comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+         class Proj = identity,
+         indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+  ranges::unique_copy_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::unique_copy(Ep&& exec, R&& r, OutR&& result_r, C comp = {}, Proj proj = {});
 ```
 Let `pred` be `equal_to{}` for the overloads in namespace `std` with no
+parameter `pred`, and let E(`i`) be
 - `bool(pred(*i, *(i - 1)))` for the overloads in namespace `std`;
 - `bool(invoke(comp, invoke(proj, *i), invoke(proj, *(i - 1))))` for the
   overloads in namespace `ranges`.
+Let:
+- M be the number of iterators `i` in the range \[`first + 1`, `last`)
+  for which E(`i`) is `false`;
+- `result_last` be `result + `M` + 1` for the overloads with no
+  parameter `result_last` or `result_r`;
+- N be min(M + 1,  `result_last - result`).
 *Mandates:* `*first` is writable [[iterator.requirements.general]] to
 `result`.
 *Preconditions:*
+- The ranges \[`first`, `last`) and \[`result`, `result + `N) do not
+  overlap.
 - For the overloads in namespace `std`:
   - The comparison function is an equivalence relation.
   - For the overloads with no `ExecutionPolicy`, let `T` be the value
     type of `InputIterator`. If `InputIterator` models
     `forward_iterator` [[iterator.concept.forward]], then there are no
     additional requirements for `T`. Otherwise, if `OutputIterator`
     meets the *Cpp17ForwardIterator* requirements and its value type is
     the same as `T`, then `T` meets the *Cpp17CopyAssignable*
     ([[cpp17.copyassignable]]) requirements. Otherwise, `T` meets both
     the *Cpp17CopyConstructible* ([[cpp17.copyconstructible]]) and
+    *Cpp17CopyAssignable* requirements.
+[*Note 1*: For the parallel algorithm overloads in namespace `std`,
+there can be a performance cost if the value type of `ForwardIterator1`
+does not meet both the *Cpp17CopyConstructible* and
+*Cpp17CopyAssignable* requirements. For the parallel algorithm overloads
+in namespace `ranges`, there can be a performance cost if
+`iter_value_t<I>` does not model `copyable`. — *end note*]
+*Effects:* Copies only the first element from N consecutive groups of
+equivalent elements referred to by the iterator `i` in the range
+\[`first + 1`, `last`) for which E(`i`) holds into the range \[`result`,
+`result + `N).
 *Returns:*
 - `result + `N for the overloads in namespace `std`.
+- `{last, result + `N`}` for the overloads in namespace `ranges`, if N
+  is equal to M + 1.
+- Otherwise, `{j, result_last}` for the overloads in namespace `ranges`,
+  where `j` is the iterator in \[`first + 1`, `last`) for which E(`j`)
+  is `false` and there are exactly N - 1 iterators `i` in \[`first + 1`,
+  `j`) for which E(`i`) is `false`.
+*Complexity:* At most `last - first - 1` applications of the
 corresponding predicate and no more than twice as many applications of
 any projection.
 ### Reverse <a id="alg.reverse">[[alg.reverse]]</a>
   requires permutable<I>
   constexpr I ranges::reverse(I first, S last);
 template<bidirectional_range R>
   requires permutable<iterator_t<R>>
   constexpr borrowed_iterator_t<R> ranges::reverse(R&& r);
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S>
+  requires permutable<I>
+  I ranges::reverse(Ep&& exec, I first, S last);
+template<execution-policy Ep, sized-random-access-range R>
+  requires permutable<iterator_t<R>>
+  borrowed_iterator_t<R> ranges::reverse(Ep&& exec, R&& r);
 ```
 *Preconditions:* For the overloads in namespace `std`,
 `BidirectionalIterator` meets the *Cpp17ValueSwappable*
 requirements [[swappable.requirements]].
 - `result + `N for the overloads in namespace `std`.
 - `{last, result + `N`}` for the overloads in namespace `ranges`.
 *Complexity:* Exactly N assignments.
+``` cpp
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS>
+  requires indirectly_copyable<I, O>
+  ranges::reverse_copy_truncated_result<I, O>
+    ranges::reverse_copy(Ep&& exec, I first, S last, O result,
+                         OutS result_last);
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+  ranges::reverse_copy_truncated_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::reverse_copy(Ep&& exec, R&& r, OutR&& result_r);
+```
+Let N be min(`last - first`,  `result_last - result`), and let
+*NEW_FIRST* be `first + (last - first) - `N.
+*Preconditions:* The ranges \[`first`, `last`) and \[`result`,
+`result + `N) do not overlap.
+*Effects:* Copies the range \[*`NEW_FIRST`*, `last`) to the range
+\[`result`, `result + `N) such that for every non-negative integer i < N
+the following assignment takes place:
+`*(result + `N` - 1 - `i`) = *(`*`NEW_FIRST`*` + `i`)`.
+*Returns:* `{last, `*`NEW_FIRST`*`, result + `N`}`.
+*Complexity:* Exactly N assignments.
 ### Rotate <a id="alg.rotate">[[alg.rotate]]</a>
 ``` cpp
 template<class ForwardIterator>
   constexpr ForwardIterator
     rotate(ExecutionPolicy&& exec,
            ForwardIterator first, ForwardIterator middle, ForwardIterator last);
 template<permutable I, sentinel_for<I> S>
   constexpr subrange<I> ranges::rotate(I first, I middle, S last);
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S>
+  requires permutable<I>
+  subrange<I> ranges::rotate(Ep&& exec, I first, I middle, S last);
 ```
 *Preconditions:* \[`first`, `middle`) and \[`middle`, `last`) are valid
 ranges. For the overloads in namespace `std`, `ForwardIterator` meets
 the *Cpp17ValueSwappable* requirements [[swappable.requirements]], and
 ```
 *Effects:* Equivalent to:
 `return ranges::rotate(ranges::begin(r), middle, ranges::end(r));`
+``` cpp
+template<execution-policy Ep, sized-random-access-range R>
+  requires permutable<iterator_t<R>>
+  borrowed_subrange_t<R> ranges::rotate(Ep&& exec, R&& r, iterator_t<R> middle);
+```
+*Effects:* Equivalent to:
+``` cpp
+return ranges::rotate(std::forward<Ep>(exec), ranges::begin(r), middle, ranges::end(r));
+```
 ``` cpp
 template<class ForwardIterator, class OutputIterator>
   constexpr OutputIterator
     rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last,
                 OutputIterator result);
 - `result + `N for the overloads in namespace `std`.
 - `{last, result + `N`}` for the overload in namespace `ranges`.
 *Complexity:* Exactly N assignments.
+``` cpp
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS>
+  requires indirectly_copyable<I, O>
+  ranges::rotate_copy_truncated_result<I, O>
+    ranges::rotate_copy(Ep&& exec, I first, I middle, S last, O result, OutS result_last);
+```
+Let M be `last - first` and N be min(M,  `result_last - result`).
+*Preconditions:* \[`first`, `middle`) and \[`middle`, `last`) are valid
+ranges. The ranges \[`first`, `last`) and \[`result`, `result + `N) do
+not overlap.
+*Effects:* Copies the range \[`first`, `last`) to the range \[`result`,
+`result + `N) such that for each non-negative integer i < N the
+following assignment takes place:
+`*(result + `i`) = *(first + (`i` + (middle - first)) % `M`)`.
+*Returns:*
+- `{middle + `N`, first, result + `N`}` if N is less than
+  `last - middle`.
+- Otherwise,
+  `{last, first + (`N` + (middle - first)) % `M`, result + `N`}`.
+*Complexity:* Exactly N assignments.
 ``` cpp
 template<forward_range R, weakly_incrementable O>
   requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::rotate_copy_result<borrowed_iterator_t<R>, O>
     ranges::rotate_copy(R&& r, iterator_t<R> middle, O result);
 ``` cpp
 return ranges::rotate_copy(ranges::begin(r), middle, ranges::end(r), std::move(result));
 ```
+``` cpp
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+  ranges::rotate_copy_truncated_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::rotate_copy(Ep&& exec, R&& r, iterator_t<R> middle, OutR&& result_r);
+```
+*Effects:* Equivalent to:
+``` cpp
+return ranges::rotate_copy(std::forward<Ep>(exec), ranges::begin(r), middle, ranges::end(r),
+                           ranges::begin(result_r), ranges::end(result_r));
+```
 ### Sample <a id="alg.random.sample">[[alg.random.sample]]</a>
 ``` cpp
 template<class PopulationIterator, class SampleIterator,
          class Distance, class UniformRandomBitGenerator>
 template<permutable I, sentinel_for<I> S>
   constexpr subrange<I> ranges::shift_left(I first, S last, iter_difference_t<I> n);
 template<forward_range R>
   requires permutable<iterator_t<R>>
+  constexpr borrowed_subrange_t<R> ranges::shift_left(R&& r, range_difference_t<R> n);
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S>
+  requires permutable<I>
+  subrange<I>
+    ranges::shift_left(Ep&& exec, I first, S last, iter_difference_t<I> n);
+template<execution-policy Ep, sized-random-access-range R>
+  requires permutable<iterator_t<R>>
+  borrowed_subrange_t<R>
+    ranges::shift_left(Ep&& exec, R&& r, range_difference_t<R> n);
 ```
 *Preconditions:* `n >= 0` is `true`. For the overloads in namespace
 `std`, the type of `*first` meets the *Cpp17MoveAssignable*
 requirements.
 *Effects:* If `n == 0` or `n >= last - first`, does nothing. Otherwise,
 moves the element from position `first + n + i` into position
 `first + i` for each non-negative integer `i < (last - first) - n`. For
+the non-parallel algorithm overloads, does so in order starting from
+`i = 0` and proceeding to `i = (last - first) - n - 1`.
 *Returns:* Let *NEW_LAST* be `first + (last - first - n)` if
+`n < last - first`, otherwise `first`. Returns:
 - *NEW_LAST* for the overloads in namespace `std`.
 - `{first, `*`NEW_LAST`*`}` for the overloads in namespace `ranges`.
 *Complexity:* At most `(last - first) - n` assignments.
 template<permutable I, sentinel_for<I> S>
   constexpr subrange<I> ranges::shift_right(I first, S last, iter_difference_t<I> n);
 template<forward_range R>
   requires permutable<iterator_t<R>>
   constexpr borrowed_subrange_t<R> ranges::shift_right(R&& r, range_difference_t<R> n);
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S>
+  requires permutable<I>
+  subrange<I>
+    ranges::shift_right(Ep&& exec, I first, S last, iter_difference_t<I> n);
+template<execution-policy Ep, sized-random-access-range R>
+  requires permutable<iterator_t<R>>
+  borrowed_subrange_t<R>
+    ranges::shift_right(Ep&& exec, R&& r, range_difference_t<R> n);
 ```
 *Preconditions:* `n >= 0` is `true`. For the overloads in namespace
 `std`, the type of `*first` meets the *Cpp17MoveAssignable*
 requirements, and `ForwardIterator` meets the
 *Effects:* If `n == 0` or `n >= last - first`, does nothing. Otherwise,
 moves the element from position `first + i` into position
 `first + n + i` for each non-negative integer `i < (last - first) - n`.
 Does so in order starting from `i = (last - first) - n - 1` and
+proceeding to `i = 0` if
+- for the non-parallel algorithm overload in namespace `std`,
+  `ForwardIterator` meets the *Cpp17BidirectionalIterator* requirements,
+- for the non-parallel algorithm overloads in namespace `ranges`, `I`
+  models `bidirectional_iterator`.
 *Returns:* Let *NEW_FIRST* be `first + n` if `n < last - first`,
+otherwise `last`. Returns:
 - *NEW_FIRST* for the overloads in namespace `std`.
 - `{`*`NEW_FIRST`*`, last}` for the overloads in namespace `ranges`.
 *Complexity:* At most `(last - first) - n` assignments or swaps.

Diff to HTML by rtfpessoa