[alg.nonmodifying] - C++17 → C++20

Files changed (1) hide show

tmp/tmppxab2jzq/{from.md → to.md} +501 -156

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

@@ -1,75 +1,114 @@
 ## Non-modifying sequence operations <a id="alg.nonmodifying">[[alg.nonmodifying]]</a>
-### All of <a id="alg.all_of">[[alg.all_of]]</a>
 ``` cpp
 template<class InputIterator, class Predicate>
-  bool all_of(InputIterator first, InputIterator last, Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   bool all_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
               Predicate pred);
 ```
-*Returns:* `true` if \[`first`, `last`) is empty or if `pred(*i)` is
-`true` for every iterator `i` in the range \[`first`, `last`), and
-`false` otherwise.
-*Complexity:* At most `last - first` applications of the predicate.
-### Any of <a id="alg.any_of">[[alg.any_of]]</a>
 ``` cpp
 template<class InputIterator, class Predicate>
-  bool any_of(InputIterator first, InputIterator last, Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   bool any_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
               Predicate pred);
 ```
-*Returns:* `false` if \[`first`, `last`) is empty or if there is no
-iterator `i` in the range \[`first`, `last`) such that `pred(*i)` is
-`true`, and `true` otherwise.
-*Complexity:* At most `last - first` applications of the predicate.
-### None of <a id="alg.none_of">[[alg.none_of]]</a>
 ``` cpp
 template<class InputIterator, class Predicate>
-  bool none_of(InputIterator first, InputIterator last, Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   bool none_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
                Predicate pred);
 ```
-*Returns:* `true` if \[`first`, `last`) is empty or if `pred(*i)` is
-`false` for every iterator `i` in the range \[`first`, `last`), and
-`false` otherwise.
-*Complexity:* At most `last - first` applications of the predicate.
 ### For each <a id="alg.foreach">[[alg.foreach]]</a>
 ``` cpp
 template<class InputIterator, class Function>
-  Function for_each(InputIterator first, InputIterator last, Function f);
 ```
-*Requires:* `Function` shall meet the requirements of
-`MoveConstructible` (Table  [[tab:moveconstructible]]).
 [*Note 1*: `Function` need not meet the requirements of
-`CopyConstructible` (Table  [[tab:copyconstructible]]). — *end note*]
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `last`), starting from `first` and proceeding to
 `last - 1`.
-[*Note 2*: If the type of `first` satisfies the requirements of a
-mutable iterator, `f` may apply non-constant functions through the
-dereferenced iterator. — *end note*]
 *Returns:* `f`.
 *Complexity:* Applies `f` exactly `last - first` times.
@@ -80,19 +119,19 @@ template<class ExecutionPolicy, class ForwardIterator, class Function>
   void for_each(ExecutionPolicy&& exec,
                 ForwardIterator first, ForwardIterator last,
                 Function f);
 ```
-*Requires:* `Function` shall meet the requirements of
-`CopyConstructible`.
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `last`).
-[*Note 3*: If the type of `first` satisfies the requirements of a
-mutable iterator, `f` may apply non-constant functions through the
-dereferenced iterator. — *end note*]
 *Complexity:* Applies `f` exactly `last - first` times.
 *Remarks:* If `f` returns a result, the result is ignored.
 Implementations do not have the freedom granted under
@@ -101,29 +140,59 @@ the input sequence.
 [*Note 4*: Does not return a copy of its `Function` parameter, since
 parallelization may not permit efficient state
 accumulation. — *end note*]
 ``` cpp
 template<class InputIterator, class Size, class Function>
-  InputIterator for_each_n(InputIterator first, Size n, Function f);
 ```
-*Requires:* `Function` shall meet the requirements of
-`MoveConstructible`
-[*Note 5*: `Function` need not meet the requirements of
-`CopyConstructible`. — *end note*]
-*Requires:* `n >= 0`.
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `first + n`) in order.
-[*Note 6*: If the type of `first` satisfies the requirements of a
-mutable iterator, `f` may apply non-constant functions through the
-dereferenced iterator. — *end note*]
 *Returns:* `first + n`.
 *Remarks:* If `f` returns a result, the result is ignored.
@@ -131,350 +200,540 @@ dereferenced iterator. — *end note*]
 template<class ExecutionPolicy, class ForwardIterator, class Size, class Function>
   ForwardIterator for_each_n(ExecutionPolicy&& exec, ForwardIterator first, Size n,
                              Function f);
 ```
-*Requires:* `Function` shall meet the requirements of
-`CopyConstructible`.
-*Requires:* `n >= 0`.
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `first + n`).
-[*Note 7*: If the type of `first` satisfies the requirements of a
-mutable iterator, `f` may apply non-constant functions through the
-dereferenced iterator. — *end note*]
 *Returns:* `first + n`.
 *Remarks:* If `f` returns a result, the result is ignored.
 Implementations do not have the freedom granted under
 [[algorithms.parallel.exec]] to make arbitrary copies of elements from
 the input sequence.
 ### Find <a id="alg.find">[[alg.find]]</a>
 ``` cpp
 template<class InputIterator, class T>
-  InputIterator find(InputIterator first, InputIterator last,
                                const T& value);
 template<class ExecutionPolicy, class ForwardIterator, class T>
   ForwardIterator find(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
                        const T& value);
 template<class InputIterator, class Predicate>
-  InputIterator find_if(InputIterator first, InputIterator last,
                                   Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   ForwardIterator find_if(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
                           Predicate pred);
 template<class InputIterator, class Predicate>
-  InputIterator find_if_not(InputIterator first, InputIterator last,
                                       Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
-  ForwardIterator find_if_not(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
                               Predicate pred);
 ```
 *Returns:* The first iterator `i` in the range \[`first`, `last`) for
-which the following corresponding conditions hold: `*i == value`,
-`pred(*i) != false`, `pred(*i) == false`. Returns `last` if no such
-iterator is found.
 *Complexity:* At most `last - first` applications of the corresponding
-predicate.
 ### Find end <a id="alg.find.end">[[alg.find.end]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
-  ForwardIterator1
     find_end(ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator1
     find_end(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2);
 template<class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
-  ForwardIterator1
     find_end(ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
   ForwardIterator1
     find_end(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
 ```
-*Effects:* Finds a subsequence of equal values in a sequence.
-*Returns:* The last iterator `i` in the range \[`first1`,
-`last1 - (last2 - first2)`) such that for every non-negative integer
-`n < (last2 - first2)`, the following corresponding conditions hold:
-`*(i + n) == *(first2 + n), pred(*(i + n), *(first2 + n)) != false`.
-Returns `last1` if \[`first2`, `last2`) is empty or if no such iterator
-is found.
 *Complexity:* At most
 `(last2 - first2) * (last1 - first1 - (last2 - first2) + 1)`
-applications of the corresponding predicate.
 ### Find first <a id="alg.find.first.of">[[alg.find.first.of]]</a>
 ``` cpp
 template<class InputIterator, class ForwardIterator>
-  InputIterator
     find_first_of(InputIterator first1, InputIterator last1,
                   ForwardIterator first2, ForwardIterator last2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator1
     find_first_of(ExecutionPolicy&& exec,
                   ForwardIterator1 first1, ForwardIterator1 last1,
                   ForwardIterator2 first2, ForwardIterator2 last2);
 template<class InputIterator, class ForwardIterator,
          class BinaryPredicate>
-  InputIterator
     find_first_of(InputIterator first1, InputIterator last1,
                   ForwardIterator first2, ForwardIterator last2,
                   BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
   ForwardIterator1
     find_first_of(ExecutionPolicy&& exec,
                   ForwardIterator1 first1, ForwardIterator1 last1,
                   ForwardIterator2 first2, ForwardIterator2 last2,
                   BinaryPredicate pred);
 ```
 *Effects:* Finds an element that matches one of a set of values.
 *Returns:* The first iterator `i` in the range \[`first1`, `last1`) such
-that for some iterator `j` in the range \[`first2`, `last2`) the
-following conditions hold: `*i == *j, pred(*i,*j) != false`. Returns
-`last1` if \[`first2`, `last2`) is empty or if no such iterator is
-found.
 *Complexity:* At most `(last1-first1) * (last2-first2)` applications of
-the corresponding predicate.
 ### Adjacent find <a id="alg.adjacent.find">[[alg.adjacent.find]]</a>
 ``` cpp
 template<class ForwardIterator>
- ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last);
 template<class ExecutionPolicy, class ForwardIterator>
-  ForwardIterator adjacent_find(ExecutionPolicy&& exec,
                   ForwardIterator first, ForwardIterator last);
 template<class ForwardIterator, class BinaryPredicate>
- ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last,
                   BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
-  ForwardIterator adjacent_find(ExecutionPolicy&& exec,
                   ForwardIterator first, ForwardIterator last,
                   BinaryPredicate pred);
 ```
 *Returns:* The first iterator `i` such that both `i` and `i + 1` are in
-the range \[`first`, `last`) for which the following corresponding
-conditions hold: `*i == *(i + 1), pred(*i, *(i + 1)) != false`. Returns
-`last` if no such iterator is found.
 *Complexity:* For the overloads with no `ExecutionPolicy`, exactly
-`min((i - first) + 1, (last - first) - 1)` applications of the
-corresponding predicate, where `i` is `adjacent_find`’s return value.
-For the overloads with an `ExecutionPolicy`, 𝑂(`last - first`)
-applications of the corresponding predicate.
 ### Count <a id="alg.count">[[alg.count]]</a>
 ``` cpp
 template<class InputIterator, class T>
-  typename iterator_traits<InputIterator>::difference_type
     count(InputIterator first, InputIterator last, const T& value);
 template<class ExecutionPolicy, class ForwardIterator, class T>
   typename iterator_traits<ForwardIterator>::difference_type
-    count(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, const T& value);
 template<class InputIterator, class Predicate>
-  typename iterator_traits<InputIterator>::difference_type
     count_if(InputIterator first, InputIterator last, Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   typename iterator_traits<ForwardIterator>::difference_type
-    count_if(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, Predicate pred);
 ```
 *Effects:* Returns the number of iterators `i` in the range \[`first`,
-`last`) for which the following corresponding conditions hold:
-`*i == value, pred(*i) != false`.
 *Complexity:* Exactly `last - first` applications of the corresponding
-predicate.
 ### Mismatch <a id="mismatch">[[mismatch]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2>
-  pair<InputIterator1, InputIterator2>
     mismatch(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   pair<ForwardIterator1, ForwardIterator2>
     mismatch(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2);
 template<class InputIterator1, class InputIterator2,
          class BinaryPredicate>
-  pair<InputIterator1, InputIterator2>
     mismatch(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
   pair<ForwardIterator1, ForwardIterator2>
     mismatch(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, BinaryPredicate pred);
 template<class InputIterator1, class InputIterator2>
-  pair<InputIterator1, InputIterator2>
     mismatch(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, InputIterator2 last2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   pair<ForwardIterator1, ForwardIterator2>
     mismatch(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2);
 template<class InputIterator1, class InputIterator2,
          class BinaryPredicate>
-  pair<InputIterator1, InputIterator2>
     mismatch(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, InputIterator2 last2,
              BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
   pair<ForwardIterator1, ForwardIterator2>
     mismatch(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
 ```
-*Remarks:* If `last2` was not given in the argument list, it denotes
-`first2 + (last1 - first1)` below.
-*Returns:* A pair of iterators `first1 + n` and `first2 + n`, where `n`
-is the smallest integer such that, respectively,
-- `!(*(first1 + n) == *(first2 + n))` or
-- `pred(*(first1 + n), *(first2 + n)) == false`,
-or `min(last1 - first1, last2 - first2)` if no such integer exists.
-*Complexity:* At most `min(last1 - first1, last2 - first2)` applications
-of the corresponding predicate.
 ### Equal <a id="alg.equal">[[alg.equal]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2>
-  bool equal(InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   bool equal(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2);
 template<class InputIterator1, class InputIterator2,
          class BinaryPredicate>
-  bool equal(InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
   bool equal(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, BinaryPredicate pred);
 template<class InputIterator1, class InputIterator2>
-  bool equal(InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 last2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   bool equal(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2);
 template<class InputIterator1, class InputIterator2,
          class BinaryPredicate>
-  bool equal(InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 last2,
                        BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
   bool equal(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
 ```
-*Remarks:* If `last2` was not given in the argument list, it denotes
-`first2 + (last1 - first1)` below.
 *Returns:* If `last1 - first1 != last2 - first2`, return `false`.
-Otherwise return `true` if for every iterator `i` in the range
-\[`first1`, `last1`) the following corresponding conditions hold:
-`*i == *(first2 + (i - first1)), pred(*i, *(first2 + (i - first1))) != false`.
-Otherwise, returns `false`.
-*Complexity:*
-- For the overloads with no `ExecutionPolicy`,
- - if `InputIterator1` and `InputIterator2` meet the requirements of
-    random access iterators ([[random.access.iterators]]) and
-    `last1 - first1 != last2 - first2`, then no applications of the
-    corresponding predicate; otherwise,
-  - at most min(`last1 - first1`, `last2 - first2`) applications of the
-    corresponding predicate.
-- For the overloads with no `ExecutionPolicy`,
-  - if `ForwardIterator1` and `ForwardIterator2` meet the requirements
-    of random access iterators and `last1 - first1 != last2 - first2`,
-    then no applications of the corresponding predicate; otherwise,
-  - 𝑂(min(`last1 - first1`, `last2 - first2`)) applications of the
-    corresponding predicate.
-### Is permutation <a id="alg.is_permutation">[[alg.is_permutation]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
-  bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                                 ForwardIterator2 first2);
 template<class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
-  bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                                 ForwardIterator2 first2, BinaryPredicate pred);
 template<class ForwardIterator1, class ForwardIterator2>
-  bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                                 ForwardIterator2 first2, ForwardIterator2 last2);
 template<class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
-  bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                                 ForwardIterator2 first2, ForwardIterator2 last2,
                                 BinaryPredicate pred);
 ```
-*Requires:* `ForwardIterator1` and `ForwardIterator2` shall have the
-same value type. The comparison function shall be an equivalence
-relation.
 *Remarks:* If `last2` was not given in the argument list, it denotes
 `first2 + (last1 - first1)` below.
 *Returns:* If `last1 - first1 != last2 - first2`, return `false`.
@@ -488,30 +747,65 @@ otherwise, returns `false`.
 `ForwardIterator1` and `ForwardIterator2` meet the requirements of
 random access iterators and `last1 - first1 != last2 - first2`.
 Otherwise, exactly `last1 - first1` applications of the corresponding
 predicate if `equal(first1, last1, first2, last2)` would return `true`
 if `pred` was not given in the argument list or
-`equal(first1, last1, first2, last2, pred)` would return `true` if pred
-was given in the argument list; otherwise, at worst 𝑂(N^2), where N has
-the value `last1 - first1`.
 ### Search <a id="alg.search">[[alg.search]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
-  ForwardIterator1
     search(ForwardIterator1 first1, ForwardIterator1 last1,
            ForwardIterator2 first2, ForwardIterator2 last2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator1
     search(ExecutionPolicy&& exec,
            ForwardIterator1 first1, ForwardIterator1 last1,
            ForwardIterator2 first2, ForwardIterator2 last2);
 template<class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
-  ForwardIterator1
     search(ForwardIterator1 first1, ForwardIterator1 last1,
            ForwardIterator2 first2, ForwardIterator2 last2,
            BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
@@ -520,68 +814,119 @@ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            ForwardIterator1 first1, ForwardIterator1 last1,
            ForwardIterator2 first2, ForwardIterator2 last2,
            BinaryPredicate pred);
 ```
-*Effects:* Finds a subsequence of equal values in a sequence.
 *Returns:* The first iterator `i` in the range \[`first1`,
 `last1 - (last2-first2)`) such that for every non-negative integer `n`
 less than `last2 - first2` the following corresponding conditions hold:
 `*(i + n) == *(first2 + n), pred(*(i + n), *(first2 + n)) != false`.
 Returns `first1` if \[`first2`, `last2`) is empty, otherwise returns
 `last1` if no such iterator is found.
 *Complexity:* At most `(last1 - first1) * (last2 - first2)` applications
 of the corresponding predicate.
 ``` cpp
 template<class ForwardIterator, class Size, class T>
-  ForwardIterator
-    search_n(ForwardIterator first, ForwardIterator last, Size count,
-             const T& value);
-template<class ForwardIterator, class Size, class T,
-         class BinaryPredicate>
-  ForwardIterator
-    search_n(ForwardIterator first, ForwardIterator last, Size count,
-             const T& value, BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Size, class T>
   ForwardIterator
     search_n(ExecutionPolicy&& exec,
              ForwardIterator first, ForwardIterator last,
              Size count, const T& value);
 template<class ExecutionPolicy, class ForwardIterator, class Size, class T,
          class BinaryPredicate>
   ForwardIterator
     search_n(ExecutionPolicy&& exec,
              ForwardIterator first, ForwardIterator last,
              Size count, const T& value,
              BinaryPredicate pred);
 ```
-*Requires:* The type `Size` shall be convertible to integral
 type ([[conv.integral]], [[class.conv]]).
-*Effects:* Finds a subsequence of equal values in a sequence.
 *Returns:* The first iterator `i` in the range \[`first`, `last-count`)
 such that for every non-negative integer `n` less than `count` the
 following corresponding conditions hold:
 `*(i + n) == value, pred(*(i + n),value) != false`. Returns `last` if no
 such iterator is found.
 *Complexity:* At most `last - first` applications of the corresponding
 predicate.
 ``` cpp
 template<class ForwardIterator, class Searcher>
- ForwardIterator search(ForwardIterator first, ForwardIterator last,
- const Searcher& searcher);
 ```
 *Effects:* Equivalent to: `return searcher(first, last).first;`
-*Remarks:* `Searcher` need not meet the `CopyConstructible`
 requirements.

 ## Non-modifying sequence operations <a id="alg.nonmodifying">[[alg.nonmodifying]]</a>
+### All of <a id="alg.all.of">[[alg.all.of]]</a>
 ``` cpp
 template<class InputIterator, class Predicate>
+ constexpr bool all_of(InputIterator first, InputIterator last, Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   bool all_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
               Predicate pred);
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  constexpr bool ranges::all_of(I first, S last, Pred pred, Proj proj = {});
+template<input_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  constexpr bool ranges::all_of(R&& r, Pred pred, Proj proj = {});
 ```
+Let E be:
+- `pred(*i)` for the overloads in namespace `std`;
+- `invoke(pred, invoke(proj, *i))` for the overloads in namespace
+  `ranges`.
+*Returns:* `false` if E is `false` for some iterator `i` in the range
+\[`first`, `last`), and `true` otherwise.
+*Complexity:* At most `last - first` applications of the predicate and
+any projection.
+### Any of <a id="alg.any.of">[[alg.any.of]]</a>
 ``` cpp
 template<class InputIterator, class Predicate>
+ constexpr bool any_of(InputIterator first, InputIterator last, Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   bool any_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
               Predicate pred);
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  constexpr bool ranges::any_of(I first, S last, Pred pred, Proj proj = {});
+template<input_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {});
 ```
+Let E be:
+- `pred(*i)` for the overloads in namespace `std`;
+- `invoke(pred, invoke(proj, *i))` for the overloads in namespace
+  `ranges`.
+*Returns:* `true` if E is `true` for some iterator `i` in the range
+\[`first`, `last`), and `false` otherwise.
+*Complexity:* At most `last - first` applications of the predicate and
+any projection.
+### None of <a id="alg.none.of">[[alg.none.of]]</a>
 ``` cpp
 template<class InputIterator, class Predicate>
+ constexpr bool none_of(InputIterator first, InputIterator last, Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   bool none_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
                Predicate pred);
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {});
+template<input_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {});
 ```
+Let E be:
+- `pred(*i)` for the overloads in namespace `std`;
+- `invoke(pred, invoke(proj, *i))` for the overloads in namespace
+  `ranges`.
+*Returns:* `false` if E is `true` for some iterator `i` in the range
+\[`first`, `last`), and `true` otherwise.
+*Complexity:* At most `last - first` applications of the predicate and
+any projection.
 ### For each <a id="alg.foreach">[[alg.foreach]]</a>
 ``` cpp
 template<class InputIterator, class Function>
+ constexpr Function for_each(InputIterator first, InputIterator last, Function f);
 ```
+*Preconditions:* `Function` meets the *Cpp17MoveConstructible*
+requirements ([[cpp17.moveconstructible]]).
 [*Note 1*: `Function` need not meet the requirements of
+*Cpp17CopyConstructible* ([[cpp17.copyconstructible]]). — *end note*]
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `last`), starting from `first` and proceeding to
 `last - 1`.
+[*Note 2*: If the type of `first` meets the requirements of a mutable
+iterator, `f` may apply non-constant functions through the dereferenced
+iterator. — *end note*]
 *Returns:* `f`.
 *Complexity:* Applies `f` exactly `last - first` times.
   void for_each(ExecutionPolicy&& exec,
                 ForwardIterator first, ForwardIterator last,
                 Function f);
 ```
+*Preconditions:* `Function` meets the *Cpp17CopyConstructible*
+requirements.
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `last`).
+[*Note 3*: If the type of `first` meets the requirements of a mutable
+iterator, `f` may apply non-constant functions through the dereferenced
+iterator. — *end note*]
 *Complexity:* Applies `f` exactly `last - first` times.
 *Remarks:* If `f` returns a result, the result is ignored.
 Implementations do not have the freedom granted under
 [*Note 4*: Does not return a copy of its `Function` parameter, since
 parallelization may not permit efficient state
 accumulation. — *end note*]
+``` cpp
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirectly_unary_invocable<projected<I, Proj>> Fun>
+  constexpr ranges::for_each_result<I, Fun>
+    ranges::for_each(I first, S last, Fun f, Proj proj = {});
+template<input_range R, class Proj = identity,
+         indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun>
+  constexpr ranges::for_each_result<borrowed_iterator_t<R>, Fun>
+    ranges::for_each(R&& r, Fun f, Proj proj = {});
+```
+*Effects:* Calls `invoke(f, invoke(proj, *i))` for every iterator `i` in
+the range \[`first`, `last`), starting from `first` and proceeding to
+`last - 1`.
+[*Note 5*: If the result of `invoke(proj, *i)` is a mutable reference,
+`f` may apply non-constant functions. — *end note*]
+*Returns:* `{last, std::move(f)}`.
+*Complexity:* Applies `f` and `proj` exactly `last - first` times.
+*Remarks:* If `f` returns a result, the result is ignored.
+[*Note 6*: The overloads in namespace `ranges` require `Fun` to model
+`copy_constructible`. — *end note*]
 ``` cpp
 template<class InputIterator, class Size, class Function>
+ constexpr InputIterator for_each_n(InputIterator first, Size n, Function f);
 ```
+*Mandates:* The type `Size` is convertible to an integral
+type ([[conv.integral]], [[class.conv]]).
+*Preconditions:* `Function` meets the *Cpp17MoveConstructible*
+requirements.
+[*Note 7*: `Function` need not meet the requirements of
+*Cpp17CopyConstructible*. — *end note*]
+*Preconditions:* `n >= 0` is `true`.
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `first + n`) in order.
+[*Note 8*: If the type of `first` meets the requirements of a mutable
+iterator, `f` may apply non-constant functions through the dereferenced
+iterator. — *end note*]
 *Returns:* `first + n`.
 *Remarks:* If `f` returns a result, the result is ignored.
 template<class ExecutionPolicy, class ForwardIterator, class Size, class Function>
   ForwardIterator for_each_n(ExecutionPolicy&& exec, ForwardIterator first, Size n,
                              Function f);
 ```
+*Mandates:* The type `Size` is convertible to an integral
+type ([[conv.integral]], [[class.conv]]).
+*Preconditions:* `Function` meets the *Cpp17CopyConstructible*
+requirements.
+*Preconditions:* `n >= 0` is `true`.
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `first + n`).
+[*Note 9*: If the type of `first` meets the requirements of a mutable
+iterator, `f` may apply non-constant functions through the dereferenced
+iterator. — *end note*]
 *Returns:* `first + n`.
 *Remarks:* If `f` returns a result, the result is ignored.
 Implementations do not have the freedom granted under
 [[algorithms.parallel.exec]] to make arbitrary copies of elements from
 the input sequence.
+``` cpp
+template<input_iterator I, class Proj = identity,
+         indirectly_unary_invocable<projected<I, Proj>> Fun>
+  constexpr ranges::for_each_n_result<I, Fun>
+    ranges::for_each_n(I first, iter_difference_t<I> n, Fun f, Proj proj = {});
+```
+*Preconditions:* `n >= 0` is `true`.
+*Effects:* Calls `invoke(f, invoke(proj, *i))` for every iterator `i` in
+the range \[`first`, `first + n`) in order.
+[*Note 10*: If the result of `invoke(proj, *i)` is a mutable reference,
+`f` may apply non-constant functions. — *end note*]
+*Returns:* `{first + n, std::move(f)}`.
+*Remarks:* If `f` returns a result, the result is ignored.
+[*Note 11*: The overload in namespace `ranges` requires `Fun` to model
+`copy_constructible`. — *end note*]
 ### Find <a id="alg.find">[[alg.find]]</a>
 ``` cpp
 template<class InputIterator, class T>
+ constexpr InputIterator find(InputIterator first, InputIterator last,
                                const T& value);
 template<class ExecutionPolicy, class ForwardIterator, class T>
   ForwardIterator find(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
                        const T& value);
 template<class InputIterator, class Predicate>
+ constexpr InputIterator find_if(InputIterator first, InputIterator last,
                                   Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   ForwardIterator find_if(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
                           Predicate pred);
 template<class InputIterator, class Predicate>
+ constexpr InputIterator find_if_not(InputIterator first, InputIterator last,
                                       Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
+  ForwardIterator find_if_not(ExecutionPolicy&& exec,
+                              ForwardIterator first, ForwardIterator last,
                               Predicate pred);
+template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
+  requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+  constexpr I ranges::find(I first, S last, const T& value, Proj proj = {});
+template<input_range R, class T, class Proj = identity>
+  requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+  constexpr borrowed_iterator_t<R>
+    ranges::find(R&& r, const T& value, Proj proj = {});
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  constexpr I ranges::find_if(I first, S last, Pred pred, Proj proj = {});
+template<input_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  constexpr borrowed_iterator_t<R>
+    ranges::find_if(R&& r, Pred pred, Proj proj = {});
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  constexpr I ranges::find_if_not(I first, S last, Pred pred, Proj proj = {});
+template<input_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  constexpr borrowed_iterator_t<R>
+    ranges::find_if_not(R&& r, Pred pred, Proj proj = {});
 ```
+Let E be:
+- `*i == value` for `find`;
+- `pred(*i) != false` for `find_if`;
+- `pred(*i) == false` for `find_if_not`;
+- `bool(invoke(proj, *i) == value)` for `ranges::find`;
+- `bool(invoke(pred, invoke(proj, *i)))` for `ranges::find_if`;
+- `bool(!invoke(pred, invoke(proj, *i)))` for `ranges::find_if_not`.
 *Returns:* The first iterator `i` in the range \[`first`, `last`) for
+which E is `true`. Returns `last` if no such iterator is found.
 *Complexity:* At most `last - first` applications of the corresponding
+predicate and any projection.
 ### Find end <a id="alg.find.end">[[alg.find.end]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
+ constexpr ForwardIterator1
     find_end(ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator1
     find_end(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2);
 template<class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
+ constexpr ForwardIterator1
     find_end(ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
   ForwardIterator1
     find_end(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
+template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  constexpr subrange<I1>
+    ranges::find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                     Proj1 proj1 = {}, Proj2 proj2 = {});
+template<forward_range R1, forward_range R2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  constexpr borrowed_subrange_t<R1>
+    ranges::find_end(R1&& r1, R2&& r2, Pred pred = {},
+                     Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
+Let:
+- `pred` be `equal_to{}` for the overloads with no parameter `pred`;
+- E be:
+  - `pred(*(i + n), *(first2 + n))` for the overloads in namespace
+ `std`;
+  - `invoke(pred, invoke(proj1, *(i + n)), invoke(proj2, *(first2 + n)))`
+    for the overloads in namespace `ranges`;
+- `i` be `last1` if \[`first2`, `last2`) is empty, or if
+  `(last2 - first2) > (last1 - first1)` is `true`, or if there is no
+  iterator in the range \[`first1`, `last1 - (last2 - first2)`) such
+  that for every non-negative integer `n < (last2 - first2)`, E is
+  `true`. Otherwise `i` is the last such iterator in \[`first1`,
+  `last1 - (last2 - first2)`).
+*Returns:*
+- `i` for the overloads in namespace `std`.
+- `{i, i + (i == last1 ? 0 : last2 - first2)}` for the overloads in
+  namespace `ranges`.
 *Complexity:* At most
 `(last2 - first2) * (last1 - first1 - (last2 - first2) + 1)`
+applications of the corresponding predicate and any projections.
 ### Find first <a id="alg.find.first.of">[[alg.find.first.of]]</a>
 ``` cpp
 template<class InputIterator, class ForwardIterator>
+ constexpr InputIterator
     find_first_of(InputIterator first1, InputIterator last1,
                   ForwardIterator first2, ForwardIterator last2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator1
     find_first_of(ExecutionPolicy&& exec,
                   ForwardIterator1 first1, ForwardIterator1 last1,
                   ForwardIterator2 first2, ForwardIterator2 last2);
 template<class InputIterator, class ForwardIterator,
          class BinaryPredicate>
+ constexpr InputIterator
     find_first_of(InputIterator first1, InputIterator last1,
                   ForwardIterator first2, ForwardIterator last2,
                   BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
   ForwardIterator1
     find_first_of(ExecutionPolicy&& exec,
                   ForwardIterator1 first1, ForwardIterator1 last1,
                   ForwardIterator2 first2, ForwardIterator2 last2,
                   BinaryPredicate pred);
+template<input_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  constexpr I1 ranges::find_first_of(I1 first1, S1 last1, I2 first2, S2 last2,
+                                     Pred pred = {},
+                                     Proj1 proj1 = {}, Proj2 proj2 = {});
+template<input_range R1, forward_range R2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  constexpr borrowed_iterator_t<R1>
+    ranges::find_first_of(R1&& r1, R2&& r2,
+                          Pred pred = {},
+                          Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
+Let E be:
+- `*i == *j` for the overloads with no parameter `pred`;
+- `pred(*i, *j) != false` for the overloads with a parameter `pred` and
+  no parameter `proj1`;
+- `bool(invoke(pred, invoke(proj1, *i), invoke(proj2, *j)))` for the
+  overloads with parameters `pred` and `proj1`.
 *Effects:* Finds an element that matches one of a set of values.
 *Returns:* The first iterator `i` in the range \[`first1`, `last1`) such
+that for some iterator `j` in the range \[`first2`, `last2`) E holds.
+Returns `last1` if \[`first2`, `last2`) is empty or if no such iterator
+is found.
 *Complexity:* At most `(last1-first1) * (last2-first2)` applications of
+the corresponding predicate and any projections.
 ### Adjacent find <a id="alg.adjacent.find">[[alg.adjacent.find]]</a>
 ``` cpp
 template<class ForwardIterator>
+ constexpr ForwardIterator
+    adjacent_find(ForwardIterator first, ForwardIterator last);
 template<class ExecutionPolicy, class ForwardIterator>
+  ForwardIterator
+    adjacent_find(ExecutionPolicy&& exec,
                   ForwardIterator first, ForwardIterator last);
 template<class ForwardIterator, class BinaryPredicate>
+ constexpr ForwardIterator
+    adjacent_find(ForwardIterator first, ForwardIterator last,
                   BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
+  ForwardIterator
+    adjacent_find(ExecutionPolicy&& exec,
                   ForwardIterator first, ForwardIterator last,
                   BinaryPredicate pred);
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_binary_predicate<projected<I, Proj>,
+                                   projected<I, Proj>> Pred = ranges::equal_to>
+  constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {});
+template<forward_range R, class Proj = identity,
+         indirect_binary_predicate<projected<iterator_t<R>, Proj>,
+                                   projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
+  constexpr borrowed_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
 ```
+Let E be:
+- `*i == *(i + 1)` for the overloads with no parameter `pred`;
+- `pred(*i, *(i + 1)) != false` for the overloads with a parameter
+  `pred` and no parameter `proj`;
+- `bool(invoke(pred, invoke(proj, *i), invoke(proj, *(i + 1))))` for the
+  overloads with both parameters `pred` and `proj`.
 *Returns:* The first iterator `i` such that both `i` and `i + 1` are in
+the range \[`first`, `last`) for which E holds. Returns `last` if no
+such iterator is found.
 *Complexity:* For the overloads with no `ExecutionPolicy`, exactly
+$$\min(\texttt{(i - first) + 1}, \ \texttt{(last - first) - 1})$$
+applications of the corresponding predicate, where `i` is
+`adjacent_find`’s return value. For the overloads with an
+`ExecutionPolicy`, 𝑂(`last - first`) applications of the corresponding
+predicate, and no more than twice as many applications of any
+projection.
 ### Count <a id="alg.count">[[alg.count]]</a>
 ``` cpp
 template<class InputIterator, class T>
+ constexpr typename iterator_traits<InputIterator>::difference_type
     count(InputIterator first, InputIterator last, const T& value);
 template<class ExecutionPolicy, class ForwardIterator, class T>
   typename iterator_traits<ForwardIterator>::difference_type
+    count(ExecutionPolicy&& exec,
+          ForwardIterator first, ForwardIterator last, const T& value);
 template<class InputIterator, class Predicate>
+ constexpr typename iterator_traits<InputIterator>::difference_type
     count_if(InputIterator first, InputIterator last, Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   typename iterator_traits<ForwardIterator>::difference_type
+    count_if(ExecutionPolicy&& exec,
+             ForwardIterator first, ForwardIterator last, Predicate pred);
+template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
+  requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+  constexpr iter_difference_t<I>
+    ranges::count(I first, S last, const T& value, Proj proj = {});
+template<input_range R, class T, class Proj = identity>
+  requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+  constexpr range_difference_t<R>
+    ranges::count(R&& r, const T& value, Proj proj = {});
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  constexpr iter_difference_t<I>
+    ranges::count_if(I first, S last, Pred pred, Proj proj = {});
+template<input_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  constexpr range_difference_t<R>
+    ranges::count_if(R&& r, Pred pred, Proj proj = {});
 ```
+Let E be:
+- `*i == value` for the overloads with no parameter `pred` or `proj`;
+- `pred(*i) != false` for the overloads with a parameter `pred` but no
+  parameter `proj`;
+- `invoke(proj, *i) == value` for the overloads with a parameter `proj`
+  but no parameter `pred`;
+- `bool(invoke(pred, invoke(proj, *i)))` for the overloads with both
+  parameters `proj` and `pred`.
 *Effects:* Returns the number of iterators `i` in the range \[`first`,
+`last`) for which E holds.
 *Complexity:* Exactly `last - first` applications of the corresponding
+predicate and any projection.
 ### Mismatch <a id="mismatch">[[mismatch]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2>
+ constexpr pair<InputIterator1, InputIterator2>
     mismatch(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   pair<ForwardIterator1, ForwardIterator2>
     mismatch(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2);
 template<class InputIterator1, class InputIterator2,
          class BinaryPredicate>
+ constexpr pair<InputIterator1, InputIterator2>
     mismatch(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
   pair<ForwardIterator1, ForwardIterator2>
     mismatch(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, BinaryPredicate pred);
 template<class InputIterator1, class InputIterator2>
+ constexpr pair<InputIterator1, InputIterator2>
     mismatch(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, InputIterator2 last2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   pair<ForwardIterator1, ForwardIterator2>
     mismatch(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2);
 template<class InputIterator1, class InputIterator2,
          class BinaryPredicate>
+ constexpr pair<InputIterator1, InputIterator2>
     mismatch(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, InputIterator2 last2,
              BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
   pair<ForwardIterator1, ForwardIterator2>
     mismatch(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  constexpr ranges::mismatch_result<I1, I2>
+    ranges::mismatch(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                     Proj1 proj1 = {}, Proj2 proj2 = {});
+template<input_range R1, input_range R2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  constexpr ranges::mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
+    ranges::mismatch(R1&& r1, R2&& r2, Pred pred = {},
+                     Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
+Let `last2` be `first2 + (last1 - first1)` for the overloads with no
+parameter `last2` or `r2`.
+Let E be:
+- `!(*(first1 + n) == *(first2 + n))` for the overloads with no
+  parameter `pred`;
+- `pred(*(first1 + n), *(first2 + n)) == false` for the overloads with a
+  parameter `pred` and no parameter `proj1`;
+- `!invoke(pred, invoke(proj1, *(first1 + n)), invoke(proj2, *(first2 + n)))`
+  for the overloads with both parameters `pred` and `proj1`.
+Let N be min(`last1 - first1`,  `last2 - first2`).
+*Returns:* `{ first1 + n, first2 + n }`, where `n` is the smallest
+integer in \[`0`, N) such that E holds, or N if no such integer exists.
+*Complexity:* At most N applications of the corresponding predicate and
+any projections.
 ### Equal <a id="alg.equal">[[alg.equal]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2>
+ constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   bool equal(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2);
 template<class InputIterator1, class InputIterator2,
          class BinaryPredicate>
+ constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
   bool equal(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, BinaryPredicate pred);
 template<class InputIterator1, class InputIterator2>
+ constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 last2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   bool equal(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2);
 template<class InputIterator1, class InputIterator2,
          class BinaryPredicate>
+ constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 last2,
                        BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
   bool equal(ExecutionPolicy&& exec,
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  constexpr bool ranges::equal(I1 first1, S1 last1, I2 first2, S2 last2,
+                               Pred pred = {},
+                               Proj1 proj1 = {}, Proj2 proj2 = {});
+template<input_range R1, input_range R2, class Pred = ranges::equal_to,
+         class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  constexpr bool ranges::equal(R1&& r1, R2&& r2, Pred pred = {},
+                               Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
+Let:
+- `last2` be `first2 + (last1 - first1)` for the overloads with no
+  parameter `last2` or `r2`;
+- `pred` be `equal_to{}` for the overloads with no parameter `pred`;
+- E be:
+  - `pred(*i, *(first2 + (i - first1)))` for the overloads with no
+    parameter `proj1`;
+  - `invoke(pred, invoke(proj1, *i), invoke(proj2, *(first2 + (i - first1))))`
+    for the overloads with parameter `proj1`.
 *Returns:* If `last1 - first1 != last2 - first2`, return `false`.
+Otherwise return `true` if E holds for every iterator `i` in the range
+\[`first1`, `last1`) Otherwise, returns `false`.
+*Complexity:* If the types of `first1`, `last1`, `first2`, and `last2`:
+- meet the *Cpp17RandomAccessIterator*
+ requirements [[random.access.iterators]] for the overloads in
+  namespace `std`;
+- pairwise model `sized_sentinel_for` [[iterator.concept.sizedsentinel]]
+  for the overloads in namespace `ranges`,
+and `last1 - first1 != last2 - first2`, then no applications of the
+corresponding predicate and each projection; otherwise,
+- For the overloads with no `ExecutionPolicy`, at most
+  min(`last1 - first1`,  `last2 - first2`) applications of the
+  corresponding predicate and any projections.
+- For the overloads with an `ExecutionPolicy`, 𝑂(min(`last1 - first1`,
+   `last2 - first2`)) applications of the corresponding predicate.
+### Is permutation <a id="alg.is.permutation">[[alg.is.permutation]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
+ constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                                 ForwardIterator2 first2);
 template<class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
+ constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                                 ForwardIterator2 first2, BinaryPredicate pred);
 template<class ForwardIterator1, class ForwardIterator2>
+ constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                                 ForwardIterator2 first2, ForwardIterator2 last2);
 template<class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
+ constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                                 ForwardIterator2 first2, ForwardIterator2 last2,
                                 BinaryPredicate pred);
 ```
+*Mandates:* `ForwardIterator1` and `ForwardIterator2` have the same
+value type.
+*Preconditions:* The comparison function is an equivalence relation.
 *Remarks:* If `last2` was not given in the argument list, it denotes
 `first2 + (last1 - first1)` below.
 *Returns:* If `last1 - first1 != last2 - first2`, return `false`.
 `ForwardIterator1` and `ForwardIterator2` meet the requirements of
 random access iterators and `last1 - first1 != last2 - first2`.
 Otherwise, exactly `last1 - first1` applications of the corresponding
 predicate if `equal(first1, last1, first2, last2)` would return `true`
 if `pred` was not given in the argument list or
+`equal(first1, last1, first2, last2, pred)` would return `true` if
+`pred` was given in the argument list; otherwise, at worst 𝑂(N^2), where
+N has the value `last1 - first1`.
+``` cpp
+template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
+         sentinel_for<I2> S2, class Proj1 = identity, class Proj2 = identity,
+         indirect_equivalence_relation<projected<I1, Proj1>,
+                                       projected<I2, Proj2>> Pred = ranges::equal_to>
+  constexpr bool ranges::is_permutation(I1 first1, S1 last1, I2 first2, S2 last2,
+                                        Pred pred = {},
+                                        Proj1 proj1 = {}, Proj2 proj2 = {});
+template<forward_range R1, forward_range R2,
+         class Proj1 = identity, class Proj2 = identity,
+         indirect_equivalence_relation<projected<iterator_t<R1>, Proj1>,
+                                       projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
+  constexpr bool ranges::is_permutation(R1&& r1, R2&& r2, Pred pred = {},
+                                        Proj1 proj1 = {}, Proj2 proj2 = {});
+```
+*Returns:* If `last1 - first1 != last2 - first2`, return `false`.
+Otherwise return `true` if there exists a permutation of the elements in
+the range \[`first2`, `last2`), bounded by \[`pfirst`, `plast`), such
+that `ranges::equal(first1, last1, pfirst, plast, pred, proj1, proj2)`
+returns `true`; otherwise, returns `false`.
+*Complexity:* No applications of the corresponding predicate and
+projections if:
+- `S1` and `I1` model `sized_sentinel_for<S1, I1>`,
+- `S2` and `I2` model `sized_sentinel_for<S2, I2>`, and
+- `last1 - first1 != last2 - first2`.
+Otherwise, exactly `last1 - first1` applications of the corresponding
+predicate and projections if
+`ranges::equal(first1, last1, first2, last2, pred, proj1, proj2)` would
+return `true`; otherwise, at worst 𝑂(N^2), where N has the value
+`last1 - first1`.
 ### Search <a id="alg.search">[[alg.search]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
+ constexpr ForwardIterator1
     search(ForwardIterator1 first1, ForwardIterator1 last1,
            ForwardIterator2 first2, ForwardIterator2 last2);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator1
     search(ExecutionPolicy&& exec,
            ForwardIterator1 first1, ForwardIterator1 last1,
            ForwardIterator2 first2, ForwardIterator2 last2);
 template<class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
+ constexpr ForwardIterator1
     search(ForwardIterator1 first1, ForwardIterator1 last1,
            ForwardIterator2 first2, ForwardIterator2 last2,
            BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryPredicate>
            ForwardIterator1 first1, ForwardIterator1 last1,
            ForwardIterator2 first2, ForwardIterator2 last2,
            BinaryPredicate pred);
 ```
 *Returns:* The first iterator `i` in the range \[`first1`,
 `last1 - (last2-first2)`) such that for every non-negative integer `n`
 less than `last2 - first2` the following corresponding conditions hold:
 `*(i + n) == *(first2 + n), pred(*(i + n), *(first2 + n)) != false`.
 Returns `first1` if \[`first2`, `last2`) is empty, otherwise returns
 `last1` if no such iterator is found.
 *Complexity:* At most `(last1 - first1) * (last2 - first2)` applications
 of the corresponding predicate.
+``` cpp
+template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
+         sentinel_for<I2> S2, class Pred = ranges::equal_to,
+         class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  constexpr subrange<I1>
+    ranges::search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                   Proj1 proj1 = {}, Proj2 proj2 = {});
+template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
+         class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  constexpr borrowed_subrange_t<R1>
+    ranges::search(R1&& r1, R2&& r2, Pred pred = {},
+                   Proj1 proj1 = {}, Proj2 proj2 = {});
+```
+*Returns:*
+- `{i, i + (last2 - first2)}`, where `i` is the first iterator in the
+  range \[`first1`, `last1 - (last2 - first2)`) such that for every
+  non-negative integer `n` less than `last2 - first2` the condition
+  ``` cpp
+  bool(invoke(pred, invoke(proj1, *(i + n)), invoke(proj2, *(first2 + n))))
+  ```
+  is `true`.
+- Returns `{last1, last1}` if no such iterator exists.
+*Complexity:* At most `(last1 - first1) * (last2 - first2)` applications
+of the corresponding predicate and projections.
 ``` cpp
 template<class ForwardIterator, class Size, class T>
+ constexpr ForwardIterator
+    search_n(ForwardIterator first, ForwardIterator last,
+ Size count, const T& value);
 template<class ExecutionPolicy, class ForwardIterator, class Size, class T>
   ForwardIterator
     search_n(ExecutionPolicy&& exec,
              ForwardIterator first, ForwardIterator last,
              Size count, const T& value);
+template<class ForwardIterator, class Size, class T,
+         class BinaryPredicate>
+  constexpr ForwardIterator
+    search_n(ForwardIterator first, ForwardIterator last,
+             Size count, const T& value,
+             BinaryPredicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Size, class T,
          class BinaryPredicate>
   ForwardIterator
     search_n(ExecutionPolicy&& exec,
              ForwardIterator first, ForwardIterator last,
              Size count, const T& value,
              BinaryPredicate pred);
 ```
+*Mandates:* The type `Size` is convertible to an integral
 type ([[conv.integral]], [[class.conv]]).
 *Returns:* The first iterator `i` in the range \[`first`, `last-count`)
 such that for every non-negative integer `n` less than `count` the
 following corresponding conditions hold:
 `*(i + n) == value, pred(*(i + n),value) != false`. Returns `last` if no
 such iterator is found.
 *Complexity:* At most `last - first` applications of the corresponding
 predicate.
+``` cpp
+template<forward_iterator I, sentinel_for<I> S, class T,
+         class Pred = ranges::equal_to, class Proj = identity>
+  requires indirectly_comparable<I, const T*, Pred, Proj>
+  constexpr subrange<I>
+    ranges::search_n(I first, S last, iter_difference_t<I> count,
+                     const T& value, Pred pred = {}, Proj proj = {});
+template<forward_range R, class T, class Pred = ranges::equal_to,
+         class Proj = identity>
+  requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
+  constexpr borrowed_subrange_t<R>
+    ranges::search_n(R&& r, range_difference_t<R> count,
+                     const T& value, Pred pred = {}, Proj proj = {});
+```
+*Returns:* `{i, i + count}` where `i` is the first iterator in the range
+\[`first`, `last - count`) such that for every non-negative integer `n`
+less than `count`, the following condition holds:
+`invoke(pred, invoke(proj, *(i + n)), value)`. Returns `{last, last}` if
+no such iterator is found.
+*Complexity:* At most `last - first` applications of the corresponding
+predicate and projection.
 ``` cpp
 template<class ForwardIterator, class Searcher>
+ constexpr ForwardIterator
+    search(ForwardIterator first, ForwardIterator last, const Searcher& searcher);
 ```
 *Effects:* Equivalent to: `return searcher(first, last).first;`
+*Remarks:* `Searcher` need not meet the *Cpp17CopyConstructible*
 requirements.

Diff to HTML by rtfpessoa