[alg.modifying.operations] - C++17 → C++20

Files changed (1) hide show

tmp/tmpl4g22fvv/{from.md → to.md} +754 -245

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

@@ -2,34 +2,46 @@
 ### Copy <a id="alg.copy">[[alg.copy]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator>
-  OutputIterator copy(InputIterator first, InputIterator last,
                                 OutputIterator result);
 ```
-*Requires:* `result` shall not be in the range \[`first`, `last`).
 *Effects:* Copies elements in the range \[`first`, `last`) into the
-range \[`result`, `result + (last - first)`) starting from `first` and
-proceeding to `last`. 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 ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator2 copy(ExecutionPolicy&& policy,
                         ForwardIterator1 first, ForwardIterator1 last,
                         ForwardIterator2 result);
 ```
-*Requires:* The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) shall 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)`.
@@ -37,247 +49,436 @@ integer `n < (last - first)`, performs `*(result + n) = *(first + n)`.
 *Complexity:* Exactly `last - first` assignments.
 ``` cpp
 template<class InputIterator, class Size, class OutputIterator>
-  OutputIterator copy_n(InputIterator first, Size n,
                                   OutputIterator result);
 template<class ExecutionPolicy, class ForwardIterator1, class Size, class ForwardIterator2>
   ForwardIterator2 copy_n(ExecutionPolicy&& exec,
                           ForwardIterator1 first, Size n,
                           ForwardIterator2 result);
 ```
-*Effects:* For each non-negative integer i < n, performs
 `*(result + i) = *(first + i)`.
-*Returns:* `result + n`.
-*Complexity:* Exactly `n` assignments.
 ``` cpp
 template<class InputIterator, class OutputIterator, class Predicate>
-  OutputIterator copy_if(InputIterator first, InputIterator last,
                                    OutputIterator result, Predicate pred);
-template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Predicate>
   ForwardIterator2 copy_if(ExecutionPolicy&& exec,
                            ForwardIterator1 first, ForwardIterator1 last,
                            ForwardIterator2 result, Predicate pred);
 ```
-*Requires:* The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) shall not overlap.
 [*Note 1*: For the overload with an `ExecutionPolicy`, there may be a
 performance cost if `iterator_traits<ForwardIterator1>::value_type` is
-not `MoveConstructible`
-(Table  [[tab:moveconstructible]]). — *end note*]
 *Effects:* Copies all of the elements referred to by the iterator `i` in
-the range \[`first`, `last`) for which `pred(*i)` is `true`.
-*Returns:* The end of the resulting range.
 *Complexity:* Exactly `last - first` applications of the corresponding
-predicate.
-*Remarks:* Stable ([[algorithm.stable]]).
 ``` cpp
 template<class BidirectionalIterator1, class BidirectionalIterator2>
-  BidirectionalIterator2
     copy_backward(BidirectionalIterator1 first,
                   BidirectionalIterator1 last,
                   BidirectionalIterator2 result);
 ```
-*Requires:* `result` shall not be in the range (`first`, `last`).
 *Effects:* Copies elements in the range \[`first`, `last`) into the
-range \[`result - (last-first)`, `result`) starting from `last - 1` and
-proceeding to `first`.[^2] For each positive integer
-`n <= (last - first)`, performs `*(result - n) = *(last - n)`.
-*Returns:* `result - (last - first)`.
-*Complexity:* Exactly `last - first` assignments.
 ### Move <a id="alg.move">[[alg.move]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator>
-  OutputIterator move(InputIterator first, InputIterator last, OutputIterator result);
 ```
-*Requires:* `result` shall not be in the range \[`first`, `last`).
 *Effects:* Moves elements in the range \[`first`, `last`) into the range
-\[`result`, `result + (last - first)`) starting from first and
-proceeding to last. For each non-negative integer `n < (last-first)`,
-performs `*(result + n)` `= std::move(*(first + n))`.
-*Returns:* `result + (last - first)`.
-*Complexity:* Exactly `last - first` move assignments.
 ``` cpp
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator2 move(ExecutionPolicy&& policy,
                         ForwardIterator1 first, ForwardIterator1 last,
                         ForwardIterator2 result);
 ```
-*Requires:* The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) shall not overlap.
 *Effects:* Moves elements in the range \[`first`, `last`) into the range
-\[`result`, `result + (last - first)`). For each non-negative integer
-`n < (last - first)`, performs
-`*(result + n) = std::move(*(first + n))`.
-*Returns:* `result + (last - first)`.
-*Complexity:* Exactly `last - first` assignments.
 ``` cpp
 template<class BidirectionalIterator1, class BidirectionalIterator2>
-  BidirectionalIterator2
-    move_backward(BidirectionalIterator1 first,
-                  BidirectionalIterator1 last,
                   BidirectionalIterator2 result);
 ```
-*Requires:* `result` shall not be in the range (`first`, `last`).
 *Effects:* Moves elements in the range \[`first`, `last`) into the range
-\[`result - (last-first)`, `result`) starting from `last - 1` and
-proceeding to first.[^3] For each positive integer
-`n <= (last - first)`, performs
-`*(result - n) = std::move(*(last - n))`.
-*Returns:* `result - (last - first)`.
-*Complexity:* Exactly `last - first` assignments.
 ### Swap <a id="alg.swap">[[alg.swap]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
-  ForwardIterator2
     swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator2
     swap_ranges(ExecutionPolicy&& exec,
                 ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2);
 ```
-*Requires:* The two ranges \[`first1`, `last1`) and \[`first2`,
-`first2 + (last1 - first1)`) shall not overlap. `*(first1 + n)` shall be
-swappable with ([[swappable.requirements]]) `*(first2 + n)`.
-*Effects:* For each non-negative integer `n < (last1 - first1)`
-performs: `swap(*(first1 + n), *(first2 + n))`.
-*Returns:* `first2 + (last1 - first1)`.
-*Complexity:* Exactly `last1 - first1` swaps.
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
-  void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
 ```
-*Requires:* `a` and `b` shall be dereferenceable. `*a` shall be
-swappable with ([[swappable.requirements]]) `*b`.
 *Effects:* As if by `swap(*a, *b)`.
 ### Transform <a id="alg.transform">[[alg.transform]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator,
          class UnaryOperation>
-  OutputIterator
-    transform(InputIterator first, InputIterator last,
               OutputIterator result, UnaryOperation op);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class UnaryOperation>
   ForwardIterator2
     transform(ExecutionPolicy&& exec,
-              ForwardIterator1 first, ForwardIterator1 last,
               ForwardIterator2 result, UnaryOperation op);
 template<class InputIterator1, class InputIterator2,
          class OutputIterator, class BinaryOperation>
-  OutputIterator
     transform(InputIterator1 first1, InputIterator1 last1,
               InputIterator2 first2, OutputIterator result,
               BinaryOperation binary_op);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class ForwardIterator, class BinaryOperation>
   ForwardIterator
     transform(ExecutionPolicy&& exec,
               ForwardIterator1 first1, ForwardIterator1 last1,
               ForwardIterator2 first2, ForwardIterator result,
               BinaryOperation binary_op);
 ```
-*Requires:* `op` and `binary_op` shall not invalidate iterators or
-subranges, or modify elements in the ranges
-- \[`first1`, `last1`\],
-- \[`first2`, `first2 + (last1 - first1)`\], and
-- \[`result`, `result + (last1 - first1)`\].[^4]
 *Effects:* Assigns through every iterator `i` in the range \[`result`,
-`result + (last1 - first1)`) a new corresponding value equal to
-`op(*(first1 + (i - result)))` or
-`binary_op(*(first1 + (i - result)), *(first2 + (i - result)))`.
-*Returns:* `result + (last1 - first1)`.
-*Complexity:* Exactly `last1 - first1` applications of `op` or
-`binary_op`. This requirement also applies to the overload with an
 `ExecutionPolicy`.
-*Remarks:* `result` may be equal to `first` in case of unary transform,
-or to `first1` or `first2` in case of binary transform.
 ### Replace <a id="alg.replace">[[alg.replace]]</a>
 ``` cpp
 template<class ForwardIterator, class T>
-  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>
-  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);
 ```
-*Requires:* The expression `*first = new_value` shall be valid.
 *Effects:* Substitutes elements referred by the iterator `i` in the
-range \[`first`, `last`) with `new_value`, when the following
-corresponding conditions hold: `*i == old_value`, `pred(*i) != false`.
 *Complexity:* Exactly `last - first` applications of the corresponding
-predicate.
 ``` cpp
 template<class InputIterator, class OutputIterator, class T>
-  OutputIterator
     replace_copy(InputIterator first, InputIterator last,
                  OutputIterator result,
                  const T& old_value, const T& new_value);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
   ForwardIterator2
@@ -285,401 +486,642 @@ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
                  ForwardIterator1 first, ForwardIterator1 last,
                  ForwardIterator2 result,
                  const T& old_value, const T& new_value);
 template<class InputIterator, class OutputIterator, class Predicate, class T>
-  OutputIterator
     replace_copy_if(InputIterator first, InputIterator last,
                     OutputIterator result,
                     Predicate pred, const T& new_value);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class Predicate, class T>
   ForwardIterator2
     replace_copy_if(ExecutionPolicy&& exec,
                     ForwardIterator1 first, ForwardIterator1 last,
                     ForwardIterator2 result,
                     Predicate pred, const T& new_value);
 ```
-*Requires:* The results of the expressions `*first` and `new_value`
-shall be writable ([[iterator.requirements.general]]) to the `result`
-output iterator. The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) shall not overlap.
-*Effects:* Assigns to every iterator `i` in the range \[`result`,
-`result + (last - first)`) either `new_value` or
-`*(first + (i - result))` depending on whether the following
-corresponding conditions hold:
-``` cpp
-*(first + (i - result)) == old_value
-pred(*(first + (i - result))) != false
-```
-*Returns:* `result + (last - first)`.
 *Complexity:* Exactly `last - first` applications of the corresponding
-predicate.
 ### Fill <a id="alg.fill">[[alg.fill]]</a>
 ``` cpp
 template<class ForwardIterator, class T>
-  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>
-  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);
 ```
-*Requires:* The expression `value` shall be
-writable ([[iterator.requirements.general]]) to the output iterator.
-The type `Size` shall be convertible to an integral
-type ([[conv.integral]], [[class.conv]]).
-*Effects:* The `fill` algorithms assign `value` through all the
-iterators in the range \[`first`, `last`). The `fill_n` algorithms
-assign `value` through all the iterators in the range \[`first`,
-`first + n`) if `n` is positive, otherwise they do nothing.
-*Returns:* `fill_n` returns `first + n` for non-negative values of `n`
-and `first` for negative values.
-*Complexity:* Exactly `last - first`, `n`, or 0 assignments,
-respectively.
 ### Generate <a id="alg.generate">[[alg.generate]]</a>
 ``` cpp
 template<class ForwardIterator, class Generator>
-  void generate(ForwardIterator first, ForwardIterator last,
                           Generator gen);
 template<class ExecutionPolicy, class ForwardIterator, class Generator>
   void generate(ExecutionPolicy&& exec,
                 ForwardIterator first, ForwardIterator last,
                 Generator gen);
 template<class OutputIterator, class Size, class Generator>
-  OutputIterator generate_n(OutputIterator first, Size n, Generator gen);
 template<class ExecutionPolicy, class ForwardIterator, class Size, class Generator>
   ForwardIterator generate_n(ExecutionPolicy&& exec,
                              ForwardIterator first, Size n, Generator gen);
 ```
-*Requires:* `gen` takes no arguments, `Size` shall be convertible to an
-integral type ([[conv.integral]], [[class.conv]]).
-*Effects:* The `generate` algorithms invoke the function object `gen`
-and assign the return value of `gen` through all the iterators in the
-range \[`first`, `last`). The `generate_n` algorithms invoke the
-function object `gen` and assign the return value of `gen` through all
-the iterators in the range \[`first`, `first + n`) if `n` is positive,
-otherwise they do nothing.
-*Returns:* `generate_n` returns `first + n` for non-negative values of
-`n` and `first` for negative values.
-*Complexity:* Exactly `last - first`, `n`, or 0 invocations of `gen` and
-assignments, respectively.
 ### Remove <a id="alg.remove">[[alg.remove]]</a>
 ``` cpp
 template<class ForwardIterator, class T>
-  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>
-  ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
                                       Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   ForwardIterator remove_if(ExecutionPolicy&& exec,
                             ForwardIterator first, ForwardIterator last,
                             Predicate pred);
 ```
-*Requires:* The type of `*first` shall satisfy the `MoveAssignable`
-requirements (Table  [[tab:moveassignable]]).
 *Effects:* Eliminates all the elements referred to by iterator `i` in
-the range \[`first`, `last`) for which the following corresponding
-conditions hold: `*i == value, pred(*i) != false`.
-*Returns:* The end of the resulting range.
-*Remarks:* Stable ([[algorithm.stable]]).
 *Complexity:* Exactly `last - first` applications of the corresponding
-predicate.
 [*Note 1*: Each element in the range \[`ret`, `last`), where `ret` is
 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>
-  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);
 template<class InputIterator, class OutputIterator, class Predicate>
-  OutputIterator
     remove_copy_if(InputIterator first, InputIterator last,
                    OutputIterator result, Predicate pred);
-template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Predicate>
   ForwardIterator2
     remove_copy_if(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
                    ForwardIterator2 result, Predicate pred);
 ```
-*Requires:* The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) shall not overlap. The expression
-`*result = *first` shall be valid.
 [*Note 2*: For the overloads with an `ExecutionPolicy`, there may be a
-performance cost if `iterator_traits<ForwardIterator1>::value_type` is
-not `MoveConstructible`
-(Table  [[tab:moveconstructible]]). — *end note*]
 *Effects:* Copies all the elements referred to by the iterator `i` in
-the range \[`first`, `last`) for which the following corresponding
-conditions do not hold: `*i == value, pred(*i) != false`.
-*Returns:* The end of the resulting range.
 *Complexity:* Exactly `last - first` applications of the corresponding
-predicate.
-*Remarks:* Stable ([[algorithm.stable]]).
 ### Unique <a id="alg.unique">[[alg.unique]]</a>
 ``` cpp
 template<class ForwardIterator>
-  ForwardIterator unique(ForwardIterator first, ForwardIterator last);
 template<class ExecutionPolicy, class ForwardIterator>
   ForwardIterator unique(ExecutionPolicy&& exec,
                          ForwardIterator first, ForwardIterator last);
 template<class ForwardIterator, class BinaryPredicate>
-  ForwardIterator unique(ForwardIterator first, ForwardIterator last,
                                    BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
   ForwardIterator unique(ExecutionPolicy&& exec,
                          ForwardIterator first, ForwardIterator last,
                          BinaryPredicate pred);
 ```
-*Requires:* The comparison function shall be an equivalence relation.
-The type of `*first` shall satisfy the `MoveAssignable` requirements
-(Table  [[tab:moveassignable]]).
 *Effects:* For a nonempty range, eliminates all but the first element
 from every consecutive group of equivalent elements referred to by the
-iterator `i` in the range \[`first + 1`, `last`) for which the following
-conditions hold: `*(i - 1) == *i` or `pred(*(i - 1), *i) != false`.
-*Returns:* The end of the resulting range.
 *Complexity:* For nonempty ranges, exactly `(last - first) - 1`
-applications of the corresponding predicate.
 ``` cpp
 template<class InputIterator, class OutputIterator>
-  OutputIterator
     unique_copy(InputIterator first, InputIterator last,
                 OutputIterator result);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator2
     unique_copy(ExecutionPolicy&& exec,
                 ForwardIterator1 first, ForwardIterator1 last,
                 ForwardIterator2 result);
 template<class InputIterator, class OutputIterator,
          class BinaryPredicate>
-  OutputIterator
     unique_copy(InputIterator first, InputIterator last,
                 OutputIterator result, BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
   ForwardIterator2
     unique_copy(ExecutionPolicy&& exec,
                 ForwardIterator1 first, ForwardIterator1 last,
                 ForwardIterator2 result, BinaryPredicate pred);
 ```
-*Requires:*
-- The comparison function shall be an equivalence relation.
 - The ranges \[`first`, `last`) and \[`result`, `result+(last-first)`)
- shall not overlap.
-- The expression `*result = *first` shall be valid.
-- For the overloads with no `ExecutionPolicy`, let `T` be the value type
- of `InputIterator`. If `InputIterator` meets the forward iterator
-  requirements, then there are no additional requirements for `T`.
-  Otherwise, if `OutputIterator` meets the forward iterator requirements
-  and its value type is the same as `T`, then `T` shall be
-  `CopyAssignable` (Table  [[tab:copyassignable]]). Otherwise, `T` shall
-  be both `CopyConstructible` (Table  [[tab:copyconstructible]]) and
-  `CopyAssignable`. \[*Note 1*: For the overloads with an
-  `ExecutionPolicy`, there may be a performance cost if the value type
-  of `ForwardIterator1` is not both `CopyConstructible` and
- `CopyAssignable`. — *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 the following corresponding conditions hold:
-`*i == *(i - 1)` or `pred(*i, *(i - 1)) != false`.
-*Returns:* The end of the resulting range.
-*Complexity:* For nonempty ranges, exactly `last - first - 1`
-applications of the corresponding predicate.
 ### Reverse <a id="alg.reverse">[[alg.reverse]]</a>
 ``` cpp
 template<class BidirectionalIterator>
-  void reverse(BidirectionalIterator first, BidirectionalIterator last);
 template<class ExecutionPolicy, class BidirectionalIterator>
   void reverse(ExecutionPolicy&& exec,
                BidirectionalIterator first, BidirectionalIterator last);
 ```
-*Requires:* `*first` shall be swappable ([[swappable.requirements]]).
 *Effects:* For each non-negative integer `i < (last - first) / 2`,
-applies `iter_swap` to all pairs of iterators
 `first + i, (last - i) - 1`.
-*Requires:* `BidirectionalIterator` shall satisfy the requirements of
-`ValueSwappable` ([[swappable.requirements]]).
 *Complexity:* Exactly `(last - first)/2` swaps.
 ``` cpp
 template<class BidirectionalIterator, class OutputIterator>
-  OutputIterator
     reverse_copy(BidirectionalIterator first, BidirectionalIterator last,
                  OutputIterator result);
 template<class ExecutionPolicy, class BidirectionalIterator, class ForwardIterator>
   ForwardIterator
     reverse_copy(ExecutionPolicy&& exec,
                  BidirectionalIterator first, BidirectionalIterator last,
                  ForwardIterator result);
 ```
-*Requires:* The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) shall not overlap.
 *Effects:* Copies the range \[`first`, `last`) to the range \[`result`,
-`result + (last - first)`) such that for every non-negative integer
-`i < (last - first)` the following assignment takes place:
-`*(result + (last - first) - 1 - i) = *(first + i)`.
-*Returns:* `result + (last - first)`.
-*Complexity:* Exactly `last - first` assignments.
 ### Rotate <a id="alg.rotate">[[alg.rotate]]</a>
 ``` cpp
 template<class ForwardIterator>
-  ForwardIterator
     rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
 template<class ExecutionPolicy, class ForwardIterator>
   ForwardIterator
     rotate(ExecutionPolicy&& exec,
            ForwardIterator first, ForwardIterator middle, ForwardIterator last);
 ```
-*Requires:* \[`first`, `middle`) and \[`middle`, `last`) shall be valid
-ranges. `ForwardIterator` shall satisfy the requirements of
-`ValueSwappable` ([[swappable.requirements]]). The type of `*first`
-shall satisfy the requirements of `MoveConstructible`
-(Table  [[tab:moveconstructible]]) and the requirements of
-`MoveAssignable` (Table  [[tab:moveassignable]]).
 *Effects:* For each non-negative integer `i < (last - first)`, places
 the element from the position `first + i` into position
 `first + (i + (last - middle)) % (last - first)`.
-*Returns:* `first + (last - middle)`.
-*Remarks:* This is a left rotate.
 *Complexity:* At most `last - first` swaps.
 ``` cpp
 template<class ForwardIterator, class OutputIterator>
-  OutputIterator
     rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last,
                 OutputIterator result);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator2
     rotate_copy(ExecutionPolicy&& exec,
                 ForwardIterator1 first, ForwardIterator1 middle, ForwardIterator1 last,
                 ForwardIterator2 result);
 ```
-*Requires:* The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) shall not overlap.
 *Effects:* Copies the range \[`first`, `last`) to the range \[`result`,
-`result + (last - first)`) such that for each non-negative integer
-`i < (last - first)` the following assignment takes place:
-`*(result + i) = *(first + (i + (middle - first)) % (last - first))`.
-*Returns:* `result + (last - first)`.
-*Complexity:* Exactly `last - first` assignments.
 ### Sample <a id="alg.random.sample">[[alg.random.sample]]</a>
 ``` cpp
 template<class PopulationIterator, class SampleIterator,
          class Distance, class UniformRandomBitGenerator>
   SampleIterator sample(PopulationIterator first, PopulationIterator last,
                         SampleIterator out, Distance n,
                         UniformRandomBitGenerator&& g);
 ```
-*Requires:*
-- `PopulationIterator` shall satisfy the requirements of an input
-  iterator ([[input.iterators]]).
-- `SampleIterator` shall satisfy the requirements of an output
-  iterator ([[output.iterators]]).
-- `SampleIterator` shall satisfy the additional requirements of a random
-  access iterator ([[random.access.iterators]]) unless
-  `PopulationIterator` satisfies the additional requirements of a
-  forward iterator ([[forward.iterators]]).
-- `PopulationIterator`’s value type shall be
-  writable ([[iterator.requirements.general]]) to `out`.
-- `Distance` shall be an integer type.
-- `remove_reference_t<UniformRandomBitGenerator>` shall meet the
-  requirements of a uniform random bit generator type
-  ([[rand.req.urng]]) whose return type is convertible to `Distance`.
-- `out` shall not be in the range \[`first`, `last`).
-*Effects:* Copies `min(last - first, n)` elements (the *sample*) from
 \[`first`, `last`) (the *population*) to `out` such that each possible
 sample has equal probability of appearance.
 [*Note 1*: Algorithms that obtain such effects include *selection
 sampling* and *reservoir sampling*. — *end note*]
@@ -688,37 +1130,104 @@ sampling* and *reservoir sampling*. — *end note*]
 *Complexity:* 𝑂(`last - first`).
 *Remarks:*
-- Stable if and only if `PopulationIterator` satisfies the requirements
- of a forward iterator.
 - To the extent that the implementation of this function makes use of
-  random numbers, the object `g` shall serve as the implementation’s
- source of randomness.
 ### Shuffle <a id="alg.random.shuffle">[[alg.random.shuffle]]</a>
 ``` cpp
 template<class RandomAccessIterator, class UniformRandomBitGenerator>
   void shuffle(RandomAccessIterator first,
                RandomAccessIterator last,
                UniformRandomBitGenerator&& g);
 ```
-*Requires:* `RandomAccessIterator` shall satisfy the requirements of
-`ValueSwappable` ([[swappable.requirements]]). The type
-`remove_reference_t<UniformRandomBitGenerator>` shall meet the
-requirements of a uniform random bit generator ([[rand.req.urng]]) type
-whose return type is convertible to
-`iterator_traits<RandomAccessIterator>::difference_type`.
 *Effects:* Permutes the elements in the range \[`first`, `last`) such
 that each possible permutation of those elements has equal probability
 of appearance.
 *Complexity:* Exactly `(last - first) - 1` swaps.
 *Remarks:* To the extent that the implementation of this function makes
-use of random numbers, the object `g` shall serve as the
 implementation’s source of randomness.

 ### Copy <a id="alg.copy">[[alg.copy]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator>
+ constexpr OutputIterator copy(InputIterator first, InputIterator last,
                                 OutputIterator result);
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
+  requires indirectly_copyable<I, O>
+  constexpr ranges::copy_result<I, O> ranges::copy(I first, S last, O result);
+template<input_range R, weakly_incrementable O>
+  requires indirectly_copyable<iterator_t<R>, O>
+  constexpr ranges::copy_result<borrowed_iterator_t<R>, O> ranges::copy(R&& r, O result);
 ```
+Let N be `last - first`.
+*Preconditions:* `result` is not in the range \[`first`, `last`).
 *Effects:* Copies 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`) = *(first + `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 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)`.
 *Complexity:* Exactly `last - first` assignments.
 ``` cpp
 template<class InputIterator, class Size, class OutputIterator>
+ constexpr OutputIterator copy_n(InputIterator first, Size n,
                                   OutputIterator result);
 template<class ExecutionPolicy, class ForwardIterator1, class Size, class ForwardIterator2>
   ForwardIterator2 copy_n(ExecutionPolicy&& exec,
                           ForwardIterator1 first, Size n,
                           ForwardIterator2 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);
 ```
+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
 `*(result + i) = *(first + i)`.
+*Returns:*
+- `result + `N for the overloads in namespace `std`.
+- `{first + `N`, result + `N`}` for the overload in namespace `ranges`.
+*Complexity:* Exactly N assignments.
 ``` cpp
 template<class InputIterator, class OutputIterator, class Predicate>
+ constexpr OutputIterator copy_if(InputIterator first, InputIterator last,
                                    OutputIterator result, Predicate pred);
+template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
+         class Predicate>
   ForwardIterator2 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,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_copyable<I, O>
+  constexpr ranges::copy_if_result<I, O>
+    ranges::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::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 may 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
 template<class BidirectionalIterator1, class BidirectionalIterator2>
+ constexpr BidirectionalIterator2
     copy_backward(BidirectionalIterator1 first,
                   BidirectionalIterator1 last,
                   BidirectionalIterator2 result);
+template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
+  requires indirectly_copyable<I1, I2>
+  constexpr ranges::copy_backward_result<I1, I2>
+    ranges::copy_backward(I1 first, S1 last, I2 result);
+template<bidirectional_range R, bidirectional_iterator I>
+  requires indirectly_copyable<iterator_t<R>, I>
+  constexpr ranges::copy_backward_result<borrowed_iterator_t<R>, I>
+    ranges::copy_backward(R&& r, I result);
 ```
+Let N be `last - first`.
+*Preconditions:* `result` is not in the range (`first`, `last`).
 *Effects:* Copies elements in the range \[`first`, `last`) into the
+range \[`result - `N, `result`) starting from `last - 1` and proceeding
+to `first`. [^2] For each positive integer n ≤ N, performs
+`*(result - `n`) = *(last - `n`)`.
+*Returns:*
+- `result - `N for the overload in namespace `std`.
+- `{last, result - `N`}` for the overloads in namespace `ranges`.
+*Complexity:* Exactly N assignments.
 ### Move <a id="alg.move">[[alg.move]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator>
+ constexpr OutputIterator move(InputIterator first, InputIterator last,
+                                OutputIterator result);
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
+  requires indirectly_movable<I, O>
+  constexpr ranges::move_result<I, O>
+    ranges::move(I first, S last, O result);
+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`.
+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>
+ constexpr BidirectionalIterator2
+    move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
                   BidirectionalIterator2 result);
+template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
+  requires indirectly_movable<I1, I2>
+  constexpr ranges::move_backward_result<I1, I2>
+    ranges::move_backward(I1 first, S1 last, I2 result);
+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`.
+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 - `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`.
+*Complexity:* Exactly N assignments.
 ### Swap <a id="alg.swap">[[alg.swap]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
+ constexpr ForwardIterator2
     swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator2
     swap_ranges(ExecutionPolicy&& exec,
                 ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2);
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2>
+  requires indirectly_swappable<I1, I2>
+  constexpr ranges::swap_ranges_result<I1, I2>
+    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]]
+`*(first2 + `n`)`.
+*Effects:* For each non-negative integer n < M performs:
+- `swap(*(first1 + `n`), *(first2 + `n`))` for the overloads in
+  namespace `std`;
+- `ranges::iter_swap(first1 + `n`, first2 + `n`)` for the overloads in
+  namespace `ranges`.
+*Returns:*
+- `last2` for the overloads in namespace `std`.
+- `{first1 + `M`, first2 + `M`}` for the overloads in namespace
+  `ranges`.
+*Complexity:* Exactly M swaps.
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
+ constexpr void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
 ```
+*Preconditions:* `a` and `b` are dereferenceable. `*a` is swappable
+with [[swappable.requirements]] `*b`.
 *Effects:* As if by `swap(*a, *b)`.
 ### Transform <a id="alg.transform">[[alg.transform]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator,
          class UnaryOperation>
+ constexpr OutputIterator
+    transform(InputIterator first1, InputIterator last1,
               OutputIterator result, UnaryOperation op);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class UnaryOperation>
   ForwardIterator2
     transform(ExecutionPolicy&& exec,
+              ForwardIterator1 first1, ForwardIterator1 last1,
               ForwardIterator2 result, UnaryOperation op);
 template<class InputIterator1, class InputIterator2,
          class OutputIterator, class BinaryOperation>
+ constexpr OutputIterator
     transform(InputIterator1 first1, InputIterator1 last1,
               InputIterator2 first2, OutputIterator result,
               BinaryOperation binary_op);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class ForwardIterator, class BinaryOperation>
   ForwardIterator
     transform(ExecutionPolicy&& exec,
               ForwardIterator1 first1, ForwardIterator1 last1,
               ForwardIterator2 first2, ForwardIterator result,
               BinaryOperation binary_op);
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
+         copy_constructible F, class Proj = identity>
+  requires indirectly_writable<O, indirect_result_t<F&, projected<I, Proj>>>
+  constexpr ranges::unary_transform_result<I, O>
+    ranges::transform(I first1, S last1, O result, F op, Proj proj = {});
+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>>>
+  constexpr ranges::binary_transform_result<I1, I2, O>
+    ranges::transform(I1 first1, S1 last1, I2 first2, S2 last2, O result,
+                      F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<input_range R1, input_range R2, weakly_incrementable O,
+         copy_constructible F, class Proj1 = identity, class Proj2 = identity>
+  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.
 ``` cpp
 template<class InputIterator, class OutputIterator, class T>
+ constexpr OutputIterator
     replace_copy(InputIterator first, InputIterator last,
                  OutputIterator result,
                  const T& old_value, const T& new_value);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
   ForwardIterator2
                  ForwardIterator1 first, ForwardIterator1 last,
                  ForwardIterator2 result,
                  const T& old_value, const T& new_value);
 template<class InputIterator, class OutputIterator, class Predicate, class T>
+ constexpr OutputIterator
     replace_copy_if(InputIterator first, InputIterator last,
                     OutputIterator result,
                     Predicate pred, const T& new_value);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class Predicate, class T>
   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.
+*Mandates:* The expression `value` is
+writable [[iterator.requirements.general]] to the output iterator. The
+type `Size` is convertible to an integral type ([[conv.integral]],
+[[class.conv]]).
+*Effects:* Assigns `value` through all the iterators in the range
+\[`first`, `first + `N).
+*Returns:* `first + `N.
+*Complexity:* Exactly N assignments.
 ### Generate <a id="alg.generate">[[alg.generate]]</a>
 ``` cpp
 template<class ForwardIterator, class Generator>
+ constexpr void generate(ForwardIterator first, ForwardIterator last,
                           Generator gen);
 template<class ExecutionPolicy, class ForwardIterator, class Generator>
   void generate(ExecutionPolicy&& exec,
                 ForwardIterator first, ForwardIterator last,
                 Generator gen);
 template<class OutputIterator, class Size, class Generator>
+ constexpr OutputIterator generate_n(OutputIterator first, Size n, Generator gen);
 template<class ExecutionPolicy, class ForwardIterator, class Size, class Generator>
   ForwardIterator generate_n(ExecutionPolicy&& exec,
                              ForwardIterator first, Size n, Generator gen);
+template<input_or_output_iterator O, sentinel_for<O> S, copy_constructible F>
+  requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
+  constexpr O ranges::generate(O first, S last, F gen);
+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.
+*Mandates:* `Size` is convertible to an integral
+type ([[conv.integral]], [[class.conv]]).
+*Effects:* Assigns the result of successive evaluations of `gen()`
+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>
+ constexpr ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
                                       Predicate pred);
 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`;
+- `bool(pred(*i))` for `remove_if`;
+- `bool(invoke(proj, *i) == value)` for `ranges::remove`;
+- `bool(invoke(pred, invoke(proj, *i)))` for `ranges::remove_if`.
+*Preconditions:* For the algorithms in namespace `std`, the type of
+`*first` meets the *Cpp17MoveAssignable* requirements
+([[cpp17.moveassignable]]).
 *Effects:* Eliminates all the elements referred to by iterator `i` in
+the range \[`first`, `last`) for which E holds.
+*Returns:* Let j be the end of the resulting range. Returns:
+- j for the overloads in namespace `std`.
+- `{`j`, last}` for the overloads in namespace `ranges`.
+*Remarks:* Stable [[algorithm.stable]].
 *Complexity:* Exactly `last - first` applications of the corresponding
+predicate and any projection.
 [*Note 1*: Each element in the range \[`ret`, `last`), where `ret` is
 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);
 template<class InputIterator, class OutputIterator, class Predicate>
+ constexpr OutputIterator
     remove_copy_if(InputIterator first, InputIterator last,
                    OutputIterator result, Predicate pred);
+template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
+         class Predicate>
   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 may 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>
 ``` cpp
 template<class ForwardIterator>
+ constexpr ForwardIterator unique(ForwardIterator first, ForwardIterator last);
 template<class ExecutionPolicy, class ForwardIterator>
   ForwardIterator unique(ExecutionPolicy&& exec,
                          ForwardIterator first, ForwardIterator last);
 template<class ForwardIterator, class BinaryPredicate>
+ constexpr ForwardIterator unique(ForwardIterator first, ForwardIterator last,
                                    BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
   ForwardIterator unique(ExecutionPolicy&& exec,
                          ForwardIterator first, ForwardIterator last,
                          BinaryPredicate pred);
+template<permutable I, sentinel_for<I> S, class Proj = identity,
+         indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
+  constexpr subrange<I> ranges::unique(I first, S last, C comp = {}, Proj proj = {});
+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
+- `bool(pred(*(i - 1), *i))` for the overloads in namespace `std`;
+- `bool(invoke(comp, invoke(proj, *(i - 1)), invoke(proj, *i)))` for the
+  overloads in namespace `ranges`.
+*Preconditions:* For the overloads in namepace `std`, `pred` is an
+equivalence relation and the type of `*first` meets the
+*Cpp17MoveAssignable* requirements ([[cpp17.moveassignable]]).
 *Effects:* For a nonempty range, eliminates all but the first element
 from every consecutive group of equivalent elements referred to by the
+iterator `i` in the range \[`first + 1`, `last`) for which E is `true`.
+*Returns:* Let j be the end of the resulting range. Returns:
+- j for the overloads in namespace `std`.
+- `{`j`, last}` for the overloads in namespace `ranges`.
 *Complexity:* For nonempty ranges, exactly `(last - first) - 1`
+applications of the corresponding predicate and no more than twice as
+many applications of any projection.
 ``` cpp
 template<class InputIterator, class OutputIterator>
+ constexpr OutputIterator
     unique_copy(InputIterator first, InputIterator last,
                 OutputIterator result);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator2
     unique_copy(ExecutionPolicy&& exec,
                 ForwardIterator1 first, ForwardIterator1 last,
                 ForwardIterator2 result);
 template<class InputIterator, class OutputIterator,
          class BinaryPredicate>
+ constexpr OutputIterator
     unique_copy(InputIterator first, InputIterator last,
                 OutputIterator result, BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
   ForwardIterator2
     unique_copy(ExecutionPolicy&& exec,
                 ForwardIterator1 first, ForwardIterator1 last,
                 ForwardIterator2 result, BinaryPredicate pred);
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
+         indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
+  requires indirectly_copyable<I, O> &&
+           (forward_iterator<I> ||
+            (input_iterator<O> && same_as<iter_value_t<I>, iter_value_t<O>>) ||
+            indirectly_copyable_storable<I, O>)
+  constexpr ranges::unique_copy_result<I, O>
+    ranges::unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});
+template<input_range R, weakly_incrementable O, class Proj = identity,
+         indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
+  requires indirectly_copyable<iterator_t<R>, O> &&
+           (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` meets the
+    *Cpp17ForwardIterator* requirements, 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 may 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>
 ``` cpp
 template<class BidirectionalIterator>
+ constexpr void reverse(BidirectionalIterator first, BidirectionalIterator last);
 template<class ExecutionPolicy, class BidirectionalIterator>
   void reverse(ExecutionPolicy&& exec,
                BidirectionalIterator first, BidirectionalIterator last);
+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]].
 *Effects:* For each non-negative integer `i < (last - first) / 2`,
+applies `std::iter_swap`, or `ranges::iter_swap` for the overloads in
+namespace `ranges`, to all pairs of iterators
 `first + i, (last - i) - 1`.
+*Returns:* `last` for the overloads in namespace `ranges`.
 *Complexity:* Exactly `(last - first)/2` swaps.
 ``` cpp
 template<class BidirectionalIterator, class OutputIterator>
+ constexpr OutputIterator
     reverse_copy(BidirectionalIterator first, BidirectionalIterator last,
                  OutputIterator result);
 template<class ExecutionPolicy, class BidirectionalIterator, class ForwardIterator>
   ForwardIterator
     reverse_copy(ExecutionPolicy&& exec,
                  BidirectionalIterator first, BidirectionalIterator last,
                  ForwardIterator result);
+template<bidirectional_iterator I, sentinel_for<I> S, weakly_incrementable O>
+  requires indirectly_copyable<I, O>
+  constexpr ranges::reverse_copy_result<I, O>
+    ranges::reverse_copy(I first, S last, O result);
+template<bidirectional_range R, weakly_incrementable O>
+  requires indirectly_copyable<iterator_t<R>, O>
+  constexpr ranges::reverse_copy_result<borrowed_iterator_t<R>, O>
+    ranges::reverse_copy(R&& r, O result);
 ```
+Let N be `last - first`.
+*Preconditions:* 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 every non-negative integer `i < `N the
+following assignment takes place:
+`*(result + `N` - 1 - i) = *(first + i)`.
+*Returns:*
+- `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
     rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
 template<class ExecutionPolicy, class ForwardIterator>
   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
+the type of `*first` meets the *Cpp17MoveConstructible*
+([[cpp17.moveconstructible]]) and *Cpp17MoveAssignable*
+([[cpp17.moveassignable]]) requirements.
 *Effects:* For each non-negative integer `i < (last - first)`, places
 the element from the position `first + i` into position
 `first + (i + (last - middle)) % (last - first)`.
+[*Note 1*: This is a left rotate. — *end note*]
+*Returns:*
+- `first + (last - middle)` for the overloads in namespace `std`.
+- `{first + (last - middle), last}` for the overload in namespace
+  `ranges`.
 *Complexity:* At most `last - first` swaps.
+``` cpp
+template<forward_range R>
+  requires permutable<iterator_t<R>>
+  constexpr borrowed_subrange_t<R> ranges::rotate(R&& r, iterator_t<R> middle);
+```
+*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);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator2
     rotate_copy(ExecutionPolicy&& exec,
                 ForwardIterator1 first, ForwardIterator1 middle, ForwardIterator1 last,
                 ForwardIterator2 result);
+  template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O>
+    requires indirectly_copyable<I, O>
+    constexpr ranges::rotate_copy_result<I, O>
+      ranges::rotate_copy(I first, I middle, S last, O result);
 ```
+Let N be `last - first`.
+*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)) % `N`)`.
+*Returns:*
+- `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);
+```
+*Effects:* Equivalent to:
+``` cpp
+return ranges::rotate_copy(ranges::begin(r), middle, ranges::end(r), result);
+```
 ### Sample <a id="alg.random.sample">[[alg.random.sample]]</a>
 ``` cpp
 template<class PopulationIterator, class SampleIterator,
          class Distance, class UniformRandomBitGenerator>
   SampleIterator sample(PopulationIterator first, PopulationIterator last,
                         SampleIterator out, Distance n,
                         UniformRandomBitGenerator&& g);
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Gen>
+  requires (forward_iterator<I> || random_access_iterator<O>) &&
+           indirectly_copyable<I, O> &&
+           uniform_random_bit_generator<remove_reference_t<Gen>>
+  O ranges::sample(I first, S last, O out, iter_difference_t<I> n, Gen&& g);
+template<input_range R, weakly_incrementable O, class Gen>
+  requires (forward_range<R> || random_access_iterator<O>) &&
+           indirectly_copyable<iterator_t<R>, O> &&
+           uniform_random_bit_generator<remove_reference_t<Gen>>
+  O ranges::sample(R&& r, O out, range_difference_t<R> n, Gen&& g);
 ```
+*Mandates:* For the overload in namespace `std`, `Distance` is an
+integer type and `*first` is writable [[iterator.requirements.general]]
+to `out`.
+*Preconditions:* `out` is not in the range \[`first`, `last`). For the
+overload in namespace `std`:
+- `PopulationIterator` meets the *Cpp17InputIterator*
+  requirements [[input.iterators]].
+- `SampleIterator` meets the *Cpp17OutputIterator*
+  requirements [[output.iterators]].
+- `SampleIterator` meets the *Cpp17RandomAccessIterator*
+  requirements [[random.access.iterators]] unless `PopulationIterator`
+  meets the *Cpp17ForwardIterator* requirements [[forward.iterators]].
+- `remove_reference_t<UniformRandomBitGenerator>` meets the requirements
+  of a uniform random bit generator type [[rand.req.urng]].
+*Effects:* Copies min(`last - first`,  `n`) elements (the *sample*) from
 \[`first`, `last`) (the *population*) to `out` such that each possible
 sample has equal probability of appearance.
 [*Note 1*: Algorithms that obtain such effects include *selection
 sampling* and *reservoir sampling*. — *end note*]
 *Complexity:* 𝑂(`last - first`).
 *Remarks:*
+- For the overload in namespace `std`, stable if and only if
+ `PopulationIterator` meets the *Cpp17ForwardIterator* requirements.
+  For the first overload in namespace `ranges`, stable if and only if
+  `I` models `forward_iterator`.
 - To the extent that the implementation of this function makes use of
+  random numbers, the object `g` serves as the implementation’s source
+  of randomness.
 ### Shuffle <a id="alg.random.shuffle">[[alg.random.shuffle]]</a>
 ``` cpp
 template<class RandomAccessIterator, class UniformRandomBitGenerator>
   void shuffle(RandomAccessIterator first,
                RandomAccessIterator last,
                UniformRandomBitGenerator&& g);
+template<random_access_iterator I, sentinel_for<I> S, class Gen>
+  requires permutable<I> &&
+           uniform_random_bit_generator<remove_reference_t<Gen>>
+  I ranges::shuffle(I first, S last, Gen&& g);
+template<random_access_range R, class Gen>
+  requires permutable<iterator_t<R>> &&
+           uniform_random_bit_generator<remove_reference_t<Gen>>
+  borrowed_iterator_t<R> ranges::shuffle(R&& r, Gen&& g);
 ```
+*Preconditions:* For the overload in namespace `std`:
+- `RandomAccessIterator` meets the *Cpp17ValueSwappable*
+ requirements [[swappable.requirements]].
+- The type `remove_reference_t<UniformRandomBitGenerator>` meets the
+  uniform random bit generator [[rand.req.urng]] requirements.
 *Effects:* Permutes the elements in the range \[`first`, `last`) such
 that each possible permutation of those elements has equal probability
 of appearance.
+*Returns:* `last` for the overloads in namespace `ranges`.
 *Complexity:* Exactly `(last - first) - 1` swaps.
 *Remarks:* To the extent that the implementation of this function makes
+use of random numbers, the object referenced by `g` shall serve as the
 implementation’s source of randomness.
+### Shift <a id="alg.shift">[[alg.shift]]</a>
+``` cpp
+template<class ForwardIterator>
+  constexpr ForwardIterator
+    shift_left(ForwardIterator first, ForwardIterator last,
+               typename iterator_traits<ForwardIterator>::difference_type n);
+template<class ExecutionPolicy, class ForwardIterator>
+  ForwardIterator
+    shift_left(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
+               typename iterator_traits<ForwardIterator>::difference_type n);
+```
+*Preconditions:* `n >= 0` is `true`. 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`. In
+the first overload case, does so in order starting from `i = 0` and
+proceeding to `i = (last - first) - n - 1`.
+*Returns:* `first + (last - first - n)` if `n < last - first`, otherwise
+`first`.
+*Complexity:* At most `(last - first) - n` assignments.
+``` cpp
+template<class ForwardIterator>
+  constexpr ForwardIterator
+    shift_right(ForwardIterator first, ForwardIterator last,
+                typename iterator_traits<ForwardIterator>::difference_type n);
+template<class ExecutionPolicy, class ForwardIterator>
+  ForwardIterator
+    shift_right(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
+                typename iterator_traits<ForwardIterator>::difference_type n);
+```
+*Preconditions:* `n >= 0` is `true`. The type of `*first` meets the
+*Cpp17MoveAssignable* requirements. `ForwardIterator` meets the
+*Cpp17BidirectionalIterator* requirements [[bidirectional.iterators]] or
+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`.
+In the first overload case, if `ForwardIterator` meets the
+*Cpp17BidirectionalIterator* requirements, does so in order starting
+from `i = (last - first) - n - 1` and proceeding to `i = 0`.
+*Returns:* `first + n` if `n < last - first`, otherwise `last`.
+*Complexity:* At most `(last - first) - n` assignments or swaps.

Diff to HTML by rtfpessoa