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

Files changed (1) hide show

tmp/tmpix419kw6/{from.md → to.md} +309 -42

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

@@ -85,10 +85,40 @@ Let E be:
 \[`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);
@@ -103,11 +133,11 @@ requirements ([[cpp17.moveconstructible]]).
 *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.
@@ -126,22 +156,22 @@ 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
 [[algorithms.parallel.exec]] to make arbitrary copies of elements from
 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<input_iterator I, sentinel_for<I> S, class Proj = identity,
          indirectly_unary_invocable<projected<I, Proj>> Fun>
@@ -156,11 +186,11 @@ template<input_range R, class Proj = identity,
 *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.
@@ -173,25 +203,23 @@ the range \[`first`, `last`), starting from `first` and proceeding to
 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.
@@ -201,22 +229,20 @@ template<class ExecutionPolicy, class ForwardIterator, class Size, class Functio
   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.
@@ -235,11 +261,11 @@ template<input_iterator I, class Proj = identity,
 *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.
@@ -307,10 +333,47 @@ Let E be:
 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
@@ -687,22 +750,28 @@ Let:
   - `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`,
@@ -726,34 +795,32 @@ template<class ForwardIterator1, class ForwardIterator2,
   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`.
 Otherwise return `true` if there exists a permutation of the elements in
-the range \[`first2`, `first2 + (last1 - first1)`), beginning with
-`ForwardIterator2 begin`, such that `equal(first1, last1, begin)`
-returns `true` or `equal(first1, last1, begin, pred)` returns `true`;
-otherwise, returns `false`.
 *Complexity:* No applications of the corresponding predicate if
 `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>,
@@ -776,13 +843,16 @@ 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
@@ -882,17 +952,17 @@ template<class ExecutionPolicy, class ForwardIterator, class Size, class T,
              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
@@ -928,5 +998,202 @@ template<class ForwardIterator, class Searcher>
 *Effects:* Equivalent to: `return searcher(first, last).first;`
 *Remarks:* `Searcher` need not meet the *Cpp17CopyConstructible*
 requirements.

 \[`first`, `last`), and `true` otherwise.
 *Complexity:* At most `last - first` applications of the predicate and
 any projection.
+### Contains <a id="alg.contains">[[alg.contains]]</a>
+``` cpp
+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 bool ranges::contains(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 bool ranges::contains(R&& r, const T& value, Proj proj = {});
+```
+*Returns:* `ranges::find(std::move(first), last, value, proj) != last`.
+``` 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 bool ranges::contains_subrange(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 bool ranges::contains_subrange(R1&& r1, R2&& r2, Pred pred = {},
+                                           Proj1 proj1 = {}, Proj2 proj2 = {});
+```
+*Returns:*
+`first2 == last2 || !ranges::search(first1, last1, first2, last2, pred, proj1, proj2).empty()`.
 ### 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);
 *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` can apply non-constant functions through the dereferenced
 iterator. — *end note*]
 *Returns:* `f`.
 *Complexity:* Applies `f` exactly `last - first` times.
 *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` can 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
 [[algorithms.parallel.exec]] to make arbitrary copies of elements from
 the input sequence.
 [*Note 4*: Does not return a copy of its `Function` parameter, since
+parallelization often does 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>
 *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` can apply non-constant functions. — *end note*]
 *Returns:* `{last, std::move(f)}`.
 *Complexity:* Applies `f` and `proj` exactly `last - first` times.
 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:* `n >= 0` is `true`. `Function` meets the
+*Cpp17MoveConstructible* requirements.
 [*Note 7*: `Function` need not meet the requirements of
 *Cpp17CopyConstructible*. — *end note*]
 *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` can apply non-constant functions through the dereferenced
 iterator. — *end note*]
 *Returns:* `first + n`.
 *Remarks:* If `f` returns a result, the result is ignored.
   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:* `n >= 0` is `true`. `Function` meets the
+*Cpp17CopyConstructible* requirements.
 *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` can apply non-constant functions through the dereferenced
 iterator. — *end note*]
 *Returns:* `first + n`.
 *Remarks:* If `f` returns a result, the result is ignored.
 *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` can apply non-constant functions. — *end note*]
 *Returns:* `{first + n, std::move(f)}`.
 *Remarks:* If `f` returns a result, the result is ignored.
 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 last <a id="alg.find.last">[[alg.find.last]]</a>
+``` cpp
+template<forward_iterator 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::find_last(I first, S last, const T& value, Proj proj = {});
+template<forward_range R, class T, class Proj = identity>
+  requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+  constexpr borrowed_subrange_t<R> ranges::find_last(R&& r, const T& value, Proj proj = {});
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  constexpr subrange<I> ranges::find_last_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>
+  constexpr borrowed_subrange_t<R> ranges::find_last_if(R&& r, Pred pred, Proj proj = {});
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  constexpr subrange<I> ranges::find_last_if_not(I first, S last, Pred pred, Proj proj = {});
+template<forward_range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  constexpr borrowed_subrange_t<R> ranges::find_last_if_not(R&& r, Pred pred, Proj proj = {});
+```
+Let E be:
+- `bool(invoke(proj, *i) == value)` for `ranges::find_last`;
+- `bool(invoke(pred, invoke(proj, *i)))` for `ranges::find_last_if`;
+- `bool(!invoke(pred, invoke(proj, *i)))` for
+  `ranges::find_last_if_not`.
+*Returns:* Let `i` be the last iterator in the range \[`first`, `last`)
+for which E is `true`. Returns `{i, last}`, or `{last, last}` if no such
+iterator is found.
+*Complexity:* At most `last - first` applications of the corresponding
+predicate and projection.
 ### Find end <a id="alg.find.end">[[alg.find.end]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
   constexpr ForwardIterator1
   - `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]]
+ and `last1 - first1 != last2 - first2` for the overloads in namespace
+ `std`;
+- the types of `first1`, `last1`, `first2`, and `last2` pairwise model
+  `sized_sentinel_for` [[iterator.concept.sizedsentinel]] and
+  `last1 - first1 != last2 - first2` for the first overload in namespace
+  `ranges`,
+- `R1` and `R2` each model `sized_range` and
+  `ranges::distance(r1) != ranges::distance(r2)` for the second overload
+  in namespace `ranges`,
+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`,
   constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                                 ForwardIterator2 first2, ForwardIterator2 last2,
                                 BinaryPredicate pred);
 ```
+Let `last2` be `first2 + (last1 - first1)` for the overloads with no
+parameter named `last2`, and let `pred` be `equal_to{}` for the
+overloads with no parameter `pred`.
 *Mandates:* `ForwardIterator1` and `ForwardIterator2` have the same
 value type.
 *Preconditions:* The comparison function is an equivalence relation.
 *Returns:* If `last1 - first1 != last2 - first2`, return `false`.
 Otherwise return `true` if there exists a permutation of the elements in
+the range \[`first2`, `last2`), beginning with `ForwardIterator2 begin`,
+such that `equal(first1, last1, begin, pred)` returns `true`; otherwise,
+returns `false`.
 *Complexity:* No applications of the corresponding predicate if
 `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, pred)` would return
+`true`; 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>,
 returns `true`; otherwise, returns `false`.
 *Complexity:* No applications of the corresponding predicate and
 projections if:
+- for the first overload,
   - `S1` and `I1` model `sized_sentinel_for<S1, I1>`,
   - `S2` and `I2` model `sized_sentinel_for<S2, I2>`, and
+ - `last1 - first1 != last2 - first2`;
+- for the second overload, `R1` and `R2` each model `sized_range`, and
+  `ranges::distance(r1) != ranges::distance(r2)`.
 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
              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
 *Effects:* Equivalent to: `return searcher(first, last).first;`
 *Remarks:* `Searcher` need not meet the *Cpp17CopyConstructible*
 requirements.
+### Starts with <a id="alg.starts.with">[[alg.starts.with]]</a>
+``` cpp
+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::starts_with(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::starts_with(R1&& r1, R2&& r2, Pred pred = {},
+                                     Proj1 proj1 = {}, Proj2 proj2 = {});
+```
+*Returns:*
+``` cpp
+ranges::mismatch(std::move(first1), last1, std::move(first2), last2,
+                 pred, proj1, proj2).in2 == last2
+```
+### Ends with <a id="alg.ends.with">[[alg.ends.with]]</a>
+``` cpp
+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 (forward_iterator<I1> || sized_sentinel_for<S1, I1>) &&
+           (forward_iterator<I2> || sized_sentinel_for<S2, I2>) &&
+           indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  constexpr bool ranges::ends_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                                   Proj1 proj1 = {}, Proj2 proj2 = {});
+```
+Let `N1` be `last1 - first1` and `N2` be `last2 - first2`.
+*Returns:* `false` if `N1` < `N2`, otherwise
+``` cpp
+ranges::equal(std::move(first1) + (N1 - N2), last1, std::move(first2), last2,
+              pred, proj1, proj2)
+```
+``` cpp
+template<input_range R1, input_range R2, class Pred = ranges::equal_to, class Proj1 = identity,
+         class Proj2 = identity>
+  requires (forward_range<R1> || sized_range<R1>) &&
+           (forward_range<R2> || sized_range<R2>) &&
+           indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  constexpr bool ranges::ends_with(R1&& r1, R2&& r2, Pred pred = {},
+                                   Proj1 proj1 = {}, Proj2 proj2 = {});
+```
+Let `N1` be `ranges::distance(r1)` and `N2` be `ranges::distance(r2)`.
+*Returns:* `false` if `N1` < `N2`, otherwise
+``` cpp
+ranges::equal(ranges::drop_view(ranges::ref_view(r1), N1 - N2), r2, pred, proj1, proj2)
+```
+### Fold <a id="alg.fold">[[alg.fold]]</a>
+``` cpp
+template<input_iterator I, sentinel_for<I> S, class T, indirectly-binary-left-foldable<T, I> F>
+  constexpr auto ranges::fold_left(I first, S last, T init, F f);
+template<input_range R, class T, indirectly-binary-left-foldable<T, iterator_t<R>> F>
+  constexpr auto ranges::fold_left(R&& r, T init, F f);
+```
+*Returns:*
+``` cpp
+ranges::fold_left_with_iter(std::move(first), last, std::move(init), f).value
+```
+``` cpp
+template<input_iterator I, sentinel_for<I> S,
+         indirectly-binary-left-foldable<iter_value_t<I>, I> F>
+  requires constructible_from<iter_value_t<I>, iter_reference_t<I>>
+  constexpr auto ranges::fold_left_first(I first, S last, F f);
+template<input_range R, indirectly-binary-left-foldable<range_value_t<R>, iterator_t<R>> F>
+  requires constructible_from<range_value_t<R>, range_reference_t<R>>
+  constexpr auto ranges::fold_left_first(R&& r, F f);
+```
+*Returns:*
+``` cpp
+ranges::fold_left_first_with_iter(std::move(first), last, f).value
+```
+``` cpp
+template<bidirectional_iterator I, sentinel_for<I> S, class T,
+         indirectly-binary-right-foldable<T, I> F>
+  constexpr auto ranges::fold_right(I first, S last, T init, F f);
+template<bidirectional_range R, class T,
+         indirectly-binary-right-foldable<T, iterator_t<R>> F>
+  constexpr auto ranges::fold_right(R&& r, T init, F f);
+```
+*Effects:* Equivalent to:
+``` cpp
+using U = decay_t<invoke_result_t<F&, iter_reference_t<I>, T>>;
+if (first == last)
+  return U(std::move(init));
+I tail = ranges::next(first, last);
+U accum = invoke(f, *--tail, std::move(init));
+while (first != tail)
+  accum = invoke(f, *--tail, std::move(accum));
+return accum;
+```
+``` cpp
+template<bidirectional_iterator I, sentinel_for<I> S,
+         indirectly-binary-right-foldable<iter_value_t<I>, I> F>
+  requires constructible_from<iter_value_t<I>, iter_reference_t<I>>
+  constexpr auto ranges::fold_right_last(I first, S last, F f);
+template<bidirectional_range R,
+         indirectly-binary-right-foldable<range_value_t<R>, iterator_t<R>> F>
+  requires constructible_from<range_value_t<R>, range_reference_t<R>>
+  constexpr auto ranges::fold_right_last(R&& r, F f);
+```
+Let `U` be
+`decltype(ranges::fold_right(first, last, iter_value_t<I>(*first), f))`.
+*Effects:* Equivalent to:
+``` cpp
+if (first == last)
+  return optional<U>();
+I tail = ranges::prev(ranges::next(first, std::move(last)));
+return optional<U>(in_place,
+  ranges::fold_right(std::move(first), tail, iter_value_t<I>(*tail), std::move(f)));
+```
+``` cpp
+template<input_iterator I, sentinel_for<I> S, class T,
+         indirectly-binary-left-foldable<T, I> F>
+  constexpr see below ranges::fold_left_with_iter(I first, S last, T init, F f);
+template<input_range R, class T, indirectly-binary-left-foldable<T, iterator_t<R>> F>
+  constexpr see below ranges::fold_left_with_iter(R&& r, T init, F f);
+```
+Let `U` be `decay_t<invoke_result_t<F&, T, iter_reference_t<I>>>`.
+*Effects:* Equivalent to:
+``` cpp
+if (first == last)
+  return {std::move(first), U(std::move(init))};
+U accum = invoke(f, std::move(init), *first);
+for (++first; first != last; ++first)
+  accum = invoke(f, std::move(accum), *first);
+return {std::move(first), std::move(accum)};
+```
+*Remarks:* The return type is `fold_left_with_iter_result<I, U>` for the
+first overload and
+`fold_left_with_iter_result<borrowed_iterator_t<R>, U>` for the second
+overload.
+``` cpp
+template<input_iterator I, sentinel_for<I> S,
+         indirectly-binary-left-foldable<iter_value_t<I>, I> F>
+  requires constructible_from<iter_value_t<I>, iter_reference_t<I>>
+  constexpr see below ranges::fold_left_first_with_iter(I first, S last, F f);
+template<input_range R, indirectly-binary-left-foldable<range_value_t<R>, iterator_t<R>> F>
+  requires constructible_from<range_value_t<R>, range_reference_t<R>>
+  constexpr see below ranges::fold_left_first_with_iter(R&& r, F f);
+```
+Let `U` be
+``` cpp
+decltype(ranges::fold_left(std::move(first), last, iter_value_t<I>(*first), f))
+```
+*Effects:* Equivalent to:
+``` cpp
+if (first == last)
+  return {std::move(first), optional<U>()};
+optional<U> init(in_place, *first);
+for (++first; first != last; ++first)
+  *init = invoke(f, std::move(*init), *first);
+return {std::move(first), std::move(init)};
+```
+*Remarks:* The return type is
+`fold_left_first_with_iter_result<I, optional<U>>` for the first
+overload and
+`fold_left_first_with_iter_result<borrowed_iterator_t<R>, optional<U>>`
+for the second overload.

Diff to HTML by rtfpessoa