Loading...
Searching...
No Matches
Algorithms

Iterator- and range-based algorithms, like the standard algorithms. More...

## Typedefs

template<typename I1 , typename I2 , typename O >
using | ranges::binary_transform_result = detail::in1_in2_out_result< I1, I2, O >
template<typename I , typename O >
using | ranges::copy_backward_result = detail::in_out_result< I, O >
template<typename I , typename O >
using | ranges::copy_if_result = detail::in_out_result< I, O >
template<typename I , typename O >
using | ranges::copy_n_result = detail::in_out_result< I, O >
template<typename I , typename O >
using | ranges::copy_result = detail::in_out_result< I, O >
template<typename I , typename F >
using | ranges::for_each_result = detail::in_fun_result< I, F >
template<typename O , typename F >
using | ranges::generate_n_result = detail::out_fun_result< O, F >
template<typename O , typename F >
using | ranges::generate_result = detail::out_fun_result< O, F >
template<typename I0 , typename I1 , typename O >
using | ranges::merge_result = detail::in1_in2_out_result< I0, I1, O >
template<typename I >
using | ranges::minmax_element_result = detail::min_max_result< I, I >
template<typename T >
using | ranges::minmax_result = detail::min_max_result< T, T >
template<typename I1 , typename I2 >
using | ranges::mismatch_result = detail::in1_in2_result< I1, I2 >
template<typename I , typename O >
using | ranges::move_backward_result = detail::in_out_result< I, O >
template<typename I , typename O >
using | ranges::move_result = detail::in_out_result< I, O >
template<typename I , typename O0 , typename O1 >
using | ranges::partition_copy_result = detail::in_out1_out2_result< I, O0, O1 >
template<typename I , typename O >
using | ranges::remove_copy_if_result = detail::in_out_result< I, O >
template<typename I , typename O >
using | ranges::remove_copy_result = detail::in_out_result< I, O >
template<typename I , typename O >
using | ranges::replace_copy_if_result = detail::in_out_result< I, O >
template<typename I , typename O >
using | ranges::replace_copy_result = detail::in_out_result< I, O >
template<typename I , typename O >
using | ranges::reverse_copy_result = detail::in_out_result< I, O >
template<typename I , typename O >
using | ranges::rotate_copy_result = detail::in_out_result< I, O >
template<typename I , typename O >
using | ranges::sample_result = detail::in_out_result< I, O >
template<typename I , typename O >
using | ranges::set_difference_result = detail::in1_out_result< I, O >
template<typename I1 , typename I2 , typename O >
using | ranges::set_symmetric_difference_result = detail::in1_in2_out_result< I1, I2, O >
template<typename I1 , typename I2 , typename O >
using | ranges::set_union_result = detail::in1_in2_out_result< I1, I2, O >
template<typename I1 , typename I2 >
using | ranges::swap_ranges_result = detail::in1_in2_result< I1, I2 >
template<typename I , typename O >
using | ranges::unary_transform_result = detail::in_out_result< I, O >
template<typename I , typename O >
using | ranges::unique_copy_result = detail::in_out_result< I, O >

## Functions

template<typename I , typename S , typename C = equal_to, typename P = identity> requires forward_iterator<I> && sentinel_for<S, I> && indirect_relation<C, projected<I, P>>
constexpr I | ranges::adjacent_find (I first, S last, C pred=C{}, P proj=P{})
| function template `adjacent_find`
template<typename Rng , typename C = equal_to, typename P = identity> requires forward_range<Rng> && indirect_relation<C, projected<iterator_t<Rng>, P>>
constexpr borrowed_iterator_t< Rng > | ranges::adjacent_find (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename Pred , typename Proj = identity> requires permutable<I> && sentinel_for<S, I> && indirect_relation<Pred, projected<I, Proj>>
constexpr I | ranges::adjacent_remove_if (I first, S last, Pred pred={}, Proj proj={})
| function `adjacent_remove_if`
template<typename Rng , typename Pred , typename Proj = identity> requires forward_range<Rng> && indirect_relation<Pred, projected<iterator_t<Rng>, Proj>> && permutable<iterator_t<Rng>>
constexpr borrowed_iterator_t< Rng > | ranges::adjacent_remove_if (Rng &&rng, Pred pred, Proj proj={})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename F , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<F, projected<I, P>>
constexpr bool | ranges::all_of (I first, S last, F pred, P proj=P{})
| function template `all_of`
template<typename Rng , typename F , typename P = identity> requires input_range<Rng> && indirect_unary_predicate<F, projected<iterator_t<Rng>, P>>
constexpr bool | ranges::all_of (Rng &&rng, F pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename F , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<F, projected<I, P>>
constexpr bool | ranges::any_of (I first, S last, F pred, P proj=P{})
| function template `any_of`
template<typename Rng , typename F , typename P = identity> requires input_range<Rng> && indirect_unary_predicate<F, projected<iterator_t<Rng>, P>>
constexpr bool | ranges::any_of (Rng &&rng, F pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename V , typename C = less, typename P = identity> requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<C, V const *, projected<I, P>>
constexpr bool | ranges::binary_search (I first, S last, V const &val, C pred=C{}, P proj=P{})
| function template `binary_search`
template<typename Rng , typename V , typename C = less, typename P = identity> requires forward_range<Rng> && indirect_strict_weak_order<C, V const *, projected<iterator_t<Rng>, P>>
constexpr bool | ranges::binary_search (Rng &&rng, V const &val, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename T , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && indirect_relation<equal_to, projected<I, P>, const T *>
constexpr bool | ranges::contains (I first, S last, const T &val, P proj={})
| function template `contains`
template<typename Rng , typename T , typename P = identity> requires input_range<Rng> && indirect_relation<equal_to, projected<iterator_t<Rng>, P>, const T *>
constexpr bool | ranges::contains (Rng &&rng, const T &val, P proj={})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename O > requires input_iterator<I> && sentinel_for<S, I> && weakly_incrementable<O> && indirectly_copyable<I, O>
constexpr copy_result< I, O > | ranges::copy (I first, S last, O out)
| function template `copy`
template<typename Rng , typename O > requires input_range<Rng> && weakly_incrementable<O> && indirectly_copyable<iterator_t<Rng>, O>
constexpr copy_result< borrowed_iterator_t< Rng >, O > | ranges::copy (Rng &&rng, O out)
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename O > requires bidirectional_iterator<I> && sentinel_for<S, I> && bidirectional_iterator<O> && indirectly_copyable<I, O>
constexpr copy_backward_result< I, O > | ranges::copy_backward (I first, S end_, O out)
| function template `copy_backward`
template<typename Rng , typename O > requires bidirectional_range<Rng> && bidirectional_iterator<O> && indirectly_copyable<iterator_t<Rng>, O>
copy_backward_result< borrowed_iterator_t< Rng >, O > constexpr | ranges::copy_backward (Rng &&rng, O out)
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename O , typename F , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && weakly_incrementable<O> && indirect_unary_predicate<F, projected<I, P>> && indirectly_copyable<I, O>
constexpr copy_if_result< I, O > | ranges::copy_if (I first, S last, O out, F pred, P proj=P{})
| function template `copy_if`
template<typename Rng , typename O , typename F , typename P = identity> requires input_range<Rng> && weakly_incrementable<O> && indirect_unary_predicate<F, projected<iterator_t<Rng>, P>> && indirectly_copyable<iterator_t<Rng>, O>
constexpr copy_if_result< borrowed_iterator_t< Rng >, O > | ranges::copy_if (Rng &&rng, O out, F pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename O , typename P = identity> requires input_iterator<I> && weakly_incrementable<O> && indirectly_copyable<I, O>
constexpr copy_n_result< I, O > | ranges::copy_n (I first, iter_difference_t< I > n, O out)
| function template `copy_n`
template<typename I , typename S , typename V , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && indirect_relation<equal_to, projected<I, P>, V const *>
constexpr iter_difference_t< I > | ranges::count (I first, S last, V const &val, P proj=P{})
| function template `count`
template<typename Rng , typename V , typename P = identity> requires input_range<Rng> && indirect_relation<equal_to, projected<iterator_t<Rng>, P>, V const *>
constexpr iter_difference_t< iterator_t< Rng > > | ranges::count (Rng &&rng, V const &val, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename R , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<R, projected<I, P>>
constexpr iter_difference_t< I > | ranges::count_if (I first, S last, R pred, P proj=P{})
| function template `count_if`
template<typename Rng , typename R , typename P = identity> requires input_range<Rng> && indirect_unary_predicate<R, projected<iterator_t<Rng>, P>>
constexpr iter_difference_t< iterator_t< Rng > > | ranges::count_if (Rng &&rng, R pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I0 , typename S0 , typename I1 , typename S1 , typename C = equal_to, typename P0 = identity, typename P1 = identity> requires ((forward_iterator<I0> && sentinel_for<S0, I0>) || (input_iterator<I0> && sized_sentinel_for<S0, I0>)) && ((forward_iterator<I1> && sentinel_for<S1, I1>) || (input_iterator<I1> && sized_sentinel_for<S1, I1>)) && indirectly_comparable<I0, I1, C, P0, P1>
constexpr bool | ranges::ends_with (I0 begin0, S0 end0, I1 begin1, S1 end1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
| function template `ends_with`
template<typename Rng0 , typename Rng1 , typename C = equal_to, typename P0 = identity, typename P1 = identity> requires (forward_range<Rng0> || (input_range<Rng0> && sized_range<Rng0>)) && (forward_range<Rng1> || (input_range<Rng1> && sized_range<Rng1>)) && indirectly_comparable<iterator_t<Rng0>, iterator_t<Rng1>, C, P0, P1>
constexpr bool | ranges::ends_with (Rng0 &&rng0, Rng1 &&rng1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I0 , typename S0 , typename I1 , typename C = equal_to, typename P0 = identity, typename P1 = identity> requires input_iterator<I0> && sentinel_for<S0, I0> && input_iterator<I1> && indirectly_comparable<I0, I1, C, P0, P1>
constexpr bool | ranges::equal (I0 begin0, S0 end0, I1 begin1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
| function template `equal`
template<typename I0 , typename S0 , typename I1 , typename S1 , typename C = equal_to, typename P0 = identity, typename P1 = identity> requires input_iterator<I0> && sentinel_for<S0, I0> && input_iterator<I1> && sentinel_for<S1, I1> && indirectly_comparable<I0, I1, C, P0, P1>
constexpr bool | ranges::equal (I0 begin0, S0 end0, I1 begin1, S1 end1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Rng0 , typename I1Ref , typename C = equal_to, typename P0 = identity, typename P1 = identity> requires input_range<Rng0> && input_iterator<uncvref_t<I1Ref>> && indirectly_comparable<iterator_t<Rng0>, uncvref_t<I1Ref>, C, P0, P1>
constexpr bool | ranges::equal (Rng0 &&rng0, I1Ref &&begin1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Rng0 , typename Rng1 , typename C = equal_to, typename P0 = identity, typename P1 = identity> requires input_range<Rng0> && input_range<Rng1> && indirectly_comparable<iterator_t<Rng0>, iterator_t<Rng1>, C, P0, P1>
constexpr bool | ranges::equal (Rng0 &&rng0, Rng1 &&rng1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename V , typename C = less, typename P = identity> requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<C, V const *, projected<I, P>>
constexpr subrange< I > | ranges::equal_range (I first, S last, V const &val, C pred=C{}, P proj=P{})
| function template `equal_range`
template<typename Rng , typename V , typename C = less, typename P = identity> requires forward_range<Rng> && indirect_strict_weak_order<C, V const *, projected<iterator_t<Rng>, P>>
constexpr borrowed_subrange_t< Rng > | ranges::equal_range (Rng &&rng, V const &val, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename O , typename S , typename V > requires output_iterator<O, V const &> && sentinel_for<S, O>
constexpr O | ranges::fill (O first, S last, V const &val)
| function template `fill`
template<typename Rng , typename V > requires output_range<Rng, V const &>
constexpr borrowed_iterator_t< Rng > | ranges::fill (Rng &&rng, V const &val)
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename O , typename V > requires output_iterator<O, V const &>
constexpr O | ranges::fill_n (O first, iter_difference_t< O > n, V const &val)
| function template `equal`
template<typename I , typename S , typename V , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && indirect_relation<equal_to, projected<I, P>, V const *>
constexpr I | ranges::find (I first, S last, V const &val, P proj=P{})
| template function `find`
template<typename Rng , typename V , typename P = identity> requires input_range<Rng> && indirect_relation<equal_to, projected<iterator_t<Rng>, P>, V const *>
constexpr borrowed_iterator_t< Rng > | ranges::find (Rng &&rng, V const &val, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I1 , typename S1 , typename I2 , typename S2 , typename R = equal_to, typename P = identity> requires forward_iterator<I1> && sentinel_for<S1, I1> && forward_iterator<I2> && sentinel_for<S2, I2> && indirect_relation<R, projected<I1, P>, I2>
constexpr subrange< I1 > | ranges::find_end (I1 begin1, S1 end1, I2 begin2, S2 end2, R pred=R{}, P proj=P{})
| function template `find_end`
template<typename Rng1 , typename Rng2 , typename R = equal_to, typename P = identity> requires forward_range<Rng1> && forward_range<Rng2> && indirect_relation<R, projected<iterator_t<Rng1>, P>, iterator_t<Rng2>>
constexpr borrowed_subrange_t< Rng1 > | ranges::find_end (Rng1 &&rng1, Rng2 &&rng2, R pred=R{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I0 , typename S0 , typename I1 , typename S1 , typename R = equal_to, typename P0 = identity, typename P1 = identity> requires input_iterator<I0> && sentinel_for<S0, I0> && forward_iterator<I1> && sentinel_for<S1, I1> && indirect_relation<R, projected<I0, P0>, projected<I1, P1>>
constexpr I0 | ranges::find_first_of (I0 begin0, S0 end0, I1 begin1, S1 end1, R pred=R{}, P0 proj0=P0{}, P1 proj1=P1{})
| function template `find_first_of`
template<typename Rng0 , typename Rng1 , typename R = equal_to, typename P0 = identity, typename P1 = identity> requires input_range<Rng0> && forward_range<Rng1> && indirect_relation<R, projected<iterator_t<Rng0>, P0>, projected<iterator_t<Rng1>, P1>>
constexpr borrowed_iterator_t< Rng0 > | ranges::find_first_of (Rng0 &&rng0, Rng1 &&rng1, R pred=R{}, P0 proj0=P0{}, P1 proj1=P1{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename F , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<F, projected<I, P>>
constexpr I | ranges::find_if (I first, S last, F pred, P proj=P{})
| template function `find`
template<typename Rng , typename F , typename P = identity> requires input_range<Rng> && indirect_unary_predicate<F, projected<iterator_t<Rng>, P>>
constexpr borrowed_iterator_t< Rng > | ranges::find_if (Rng &&rng, F pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename F , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<F, projected<I, P>>
constexpr I | ranges::find_if_not (I first, S last, F pred, P proj=P{})
| template function `find_if_not`
template<typename Rng , typename F , typename P = identity> requires input_range<Rng> && indirect_unary_predicate<F, projected<iterator_t<Rng>, P>>
constexpr borrowed_iterator_t< Rng > | ranges::find_if_not (Rng &&rng, F pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename T , typename Op > requires sentinel_for<S, I> && input_iterator<I> && indirectly_binary_left_foldable<Op, T, I>
constexpr auto | ranges::fold_left (I first, S last, T init, Op op)
template<typename Rng , typename T , typename Op > requires input_range<Rng> && indirectly_binary_left_foldable<Op, T, iterator_t<Rng>>
constexpr auto | ranges::fold_left (Rng &&rng, T init, Op op)
template<typename I , typename S , typename Op > requires sentinel_for<S, I> && input_iterator<I> && indirectly_binary_left_foldable<Op, iter_value_t<I>, I> && constructible_from<iter_value_t<I>, iter_reference_t<I>>
constexpr auto | ranges::fold_left_first (I first, S last, Op op)
template<typename R , typename Op > requires input_range<R> && indirectly_binary_left_foldable<Op, range_value_t<R>, iterator_t<R>> && constructible_from<range_value_t<R>, range_reference_t<R>>
constexpr auto | ranges::fold_left_first (R &&rng, Op op)
template<typename I , typename S , typename T , typename Op > requires sentinel_for<S, I> && bidirectional_iterator<I> && indirectly_binary_right_foldable<Op, T, I>
constexpr auto | ranges::fold_right (I first, S last, T init, Op op)
template<typename Rng , typename T , typename Op > requires bidirectional_range<Rng> && indirectly_binary_right_foldable<Op, T, iterator_t<Rng>>
constexpr auto | ranges::fold_right (Rng &&rng, T init, Op op)
template<typename I , typename S , typename Op > requires sentinel_for<S, I> && bidirectional_iterator<I> && indirectly_binary_right_foldable<Op, iter_value_t<I>, I> && constructible_from<iter_value_t<I>, iter_reference_t<I>>
constexpr auto | ranges::fold_right_last (I first, S last, Op op)
template<typename R , typename Op > requires bidirectional_range<R> && indirectly_binary_right_foldable<Op, range_value_t<R>, iterator_t<R>> && constructible_from<range_value_t<R>, range_reference_t<R>>
constexpr auto | ranges::fold_right_last (R &&rng, Op op)
template<typename I , typename S , typename F , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && indirectly_unary_invocable<F, projected<I, P>>
constexpr for_each_result< I, F > | ranges::for_each (I first, S last, F fun, P proj=P{})
| function template `for_each`
template<typename Rng , typename F , typename P = identity> requires input_range<Rng> && indirectly_unary_invocable<F, projected<iterator_t<Rng>, P>>
constexpr for_each_result< borrowed_iterator_t< Rng >, F > | ranges::for_each (Rng &&rng, F fun, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename F , typename P = identity> requires input_iterator<I> && indirectly_unary_invocable<F, projected<I, P>>
constexpr I | ranges::for_each_n (I first, iter_difference_t< I > n, F fun, P proj=P{})
| function template `for_each_n`
template<typename Rng , typename F , typename P = identity> requires input_range<Rng> && indirectly_unary_invocable<F, projected<iterator_t<Rng>, P>>
constexpr borrowed_iterator_t< Rng > | ranges::for_each_n (Rng &&rng, range_difference_t< Rng > n, F fun, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename O , typename S , typename F > requires invocable<F &> && output_iterator<O, invoke_result_t<F &>> && sentinel_for<S, O>
constexpr generate_result< O, F > | ranges::generate (O first, S last, F fun)
| function template `generate_n`
template<typename Rng , typename F > requires invocable<F &> && output_range<Rng, invoke_result_t<F &>>
constexpr generate_result< borrowed_iterator_t< Rng >, F > | ranges::generate (Rng &&rng, F fun)
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename O , typename F > requires invocable<F &> && output_iterator<O, invoke_result_t<F &>>
constexpr generate_n_result< O, F > | ranges::generate_n (O first, iter_difference_t< O > n, F fun)
| function template `generate_n`
template<typename I1 , typename S1 , typename I2 , typename S2 , typename C = less, typename P1 = identity, typename P2 = identity> requires input_iterator<I1> && sentinel_for<S1, I1> && input_iterator<I2> && sentinel_for<S2, I2> && indirect_strict_weak_order<C, projected<I1, P1>, projected<I2, P2>>
constexpr bool | ranges::includes (I1 begin1, S1 end1, I2 begin2, S2 end2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| function template `includes`
template<typename Rng1 , typename Rng2 , typename C = less, typename P1 = identity, typename P2 = identity> requires input_range<Rng1> && input_range<Rng2> && indirect_strict_weak_order<C, projected<iterator_t<Rng1>, P1>, projected<iterator_t<Rng2>, P2>>
constexpr bool | ranges::includes (Rng1 &&rng1, Rng2 &&rng2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C = less, typename P = identity> requires bidirectional_iterator<I> && sortable<I, C, P>
I | ranges::inplace_merge (I first, I middle, S last, C pred=C{}, P proj=P{})
| function template `inplace_merge`
template<typename Rng , typename C = less, typename P = identity> requires bidirectional_range<Rng> && sortable<iterator_t<Rng>, C, P>
borrowed_iterator_t< Rng > | ranges::inplace_merge (Rng &&rng, iterator_t< Rng > middle, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C = less, typename P = identity> requires random_access_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<C, projected<I, P>>
constexpr bool | ranges::is_heap (I first, S last, C pred=C{}, P proj=P{})
| function template `is_heap`
template<typename Rng , typename C = less, typename P = identity> requires random_access_range<Rng> && indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>>
constexpr bool | ranges::is_heap (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C = less, typename P = identity> requires random_access_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<C, projected<I, P>>
constexpr I | ranges::is_heap_until (I first, S last, C pred=C{}, P proj=P{})
| function template `is_heap_until`
template<typename Rng , typename C = less, typename P = identity> requires random_access_range<Rng> && indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>>
constexpr borrowed_iterator_t< Rng > | ranges::is_heap_until (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<C, projected<I, P>>
constexpr bool | ranges::is_partitioned (I first, S last, C pred, P proj=P{})
| function template `is_partitioned`
template<typename Rng , typename C , typename P = identity> requires input_range<Rng> && indirect_unary_predicate<C, projected<iterator_t<Rng>, P>>
constexpr bool | ranges::is_partitioned (Rng &&rng, C pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I1 , typename S1 , typename I2 , typename C = equal_to, typename P1 = identity, typename P2 = identity> requires forward_iterator<I1> && sentinel_for<S1, I1> && forward_iterator<I2> && indirectly_comparable<I1, I2, C, P1, P2>
bool | ranges::is_permutation (I1 begin1, S1 end1, I2 begin2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| function template `is_permutation`
template<typename I1 , typename S1 , typename I2 , typename S2 , typename C = equal_to, typename P1 = identity, typename P2 = identity> requires forward_iterator<I1> && sentinel_for<S1, I1> && forward_iterator<I2> && sentinel_for<S2, I2> && indirectly_comparable<I1, I2, C, P1, P2>
constexpr bool | ranges::is_permutation (I1 begin1, S1 end1, I2 begin2, S2 end2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Rng1 , typename I2Ref , typename C = equal_to, typename P1 = identity, typename P2 = identity> requires forward_range<Rng1> && forward_iterator<uncvref_t<I2Ref>> && indirectly_comparable<iterator_t<Rng1>, uncvref_t<I2Ref>, C, P1, P2>
bool | ranges::is_permutation (Rng1 &&rng1, I2Ref &&begin2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Rng1 , typename Rng2 , typename C = equal_to, typename P1 = identity, typename P2 = identity> requires forward_range<Rng1> && forward_range<Rng2> && indirectly_comparable<iterator_t<Rng1>, iterator_t<Rng2>, C, P1, P2>
constexpr bool | ranges::is_permutation (Rng1 &&rng1, Rng2 &&rng2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename R = less, typename P = identity> requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<R, projected<I, P>>
constexpr bool | ranges::is_sorted (I first, S last, R rel=R{}, P proj=P{})
| template function `is_sorted`
template<typename Rng , typename R = less, typename P = identity> requires forward_range<Rng> && indirect_strict_weak_order<R, projected<iterator_t<Rng>, P>>
constexpr bool | ranges::is_sorted (Rng &&rng, R rel=R{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename R = less, typename P = identity> requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<R, projected<I, P>>
constexpr I | ranges::is_sorted_until (I first, S last, R pred=R{}, P proj=P{})
| template function `is_sorted_until`
template<typename Rng , typename R = less, typename P = identity> requires forward_range<Rng> && indirect_strict_weak_order<R, projected<iterator_t<Rng>, P>>
constexpr borrowed_iterator_t< Rng > | ranges::is_sorted_until (Rng &&rng, R pred=R{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I0 , typename S0 , typename I1 , typename S1 , typename C = less, typename P0 = identity, typename P1 = identity> requires input_iterator<I0> && sentinel_for<S0, I0> && input_iterator<I1> && sentinel_for<S1, I1> && indirect_strict_weak_order<C, projected<I0, P0>, projected<I1, P1>>
constexpr bool | ranges::lexicographical_compare (I0 begin0, S0 end0, I1 begin1, S1 end1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
| function template `lexicographical_compare`
template<typename Rng0 , typename Rng1 , typename C = less, typename P0 = identity, typename P1 = identity> requires input_range<Rng0> && input_range<Rng1> && indirect_strict_weak_order<C, projected<iterator_t<Rng0>, P0>, projected<iterator_t<Rng1>, P1>>
constexpr bool | ranges::lexicographical_compare (Rng0 &&rng0, Rng1 &&rng1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename V , typename C = less, typename P = identity> requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<C, V const *, projected<I, P>>
constexpr I | ranges::lower_bound (I first, S last, V const &val, C pred=C{}, P proj=P{})
| function template `lower_bound`
template<typename Rng , typename V , typename C = less, typename P = identity> requires forward_range<Rng> && indirect_strict_weak_order<C, V const *, projected<iterator_t<Rng>, P>>
constexpr borrowed_iterator_t< Rng > | ranges::lower_bound (Rng &&rng, V const &val, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C = less, typename P = identity> requires random_access_iterator<I> && sentinel_for<S, I> && sortable<I, C, P>
constexpr I | ranges::make_heap (I first, S last, C pred=C{}, P proj=P{})
| function template `make_heap`
template<typename Rng , typename C = less, typename P = identity> requires random_access_range<Rng> && sortable<iterator_t<Rng>, C, P>
constexpr borrowed_iterator_t< Rng > | ranges::make_heap (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Rng , typename C = less, typename P = identity> requires input_range<Rng> && indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>> && indirectly_copyable_storable<iterator_t<Rng>, range_value_t<Rng> *>
constexpr range_value_t< Rng > | ranges::max (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename T , typename C = less, typename P = identity> requires copyable<T> && indirect_strict_weak_order<C, projected<T const *, P>>
constexpr T | ranges::max (std::initializer_list< T > const &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename T , typename C = less, typename P = identity> requires indirect_strict_weak_order<C, projected<T const *, P>>
constexpr T const & | ranges::max (T const &a, T const &b, C pred=C{}, P proj=P{})
| function template `max`
template<typename I , typename S , typename C = less, typename P = identity> requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<C, projected<I, P>>
constexpr I | ranges::max_element (I first, S last, C pred=C{}, P proj=P{})
| function template `max_element`
template<typename Rng , typename C = less, typename P = identity> requires forward_range<Rng> && indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>>
constexpr borrowed_iterator_t< Rng > | ranges::max_element (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I0 , typename S0 , typename I1 , typename S1 , typename O , typename C = less, typename P0 = identity, typename P1 = identity> requires sentinel_for<S0, I0> && sentinel_for<S1, I1> && mergeable<I0, I1, O, C, P0, P1>
constexpr merge_result< I0, I1, O > | ranges::merge (I0 begin0, S0 end0, I1 begin1, S1 end1, O out, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
| function template `merge`
template<typename Rng0 , typename Rng1 , typename O , typename C = less, typename P0 = identity, typename P1 = identity> requires range<Rng0> && range<Rng1> && mergeable<iterator_t<Rng0>, iterator_t<Rng1>, O, C, P0, P1>
constexpr merge_result< borrowed_iterator_t< Rng0 >, borrowed_iterator_t< Rng1 >, O > | ranges::merge (Rng0 &&rng0, Rng1 &&rng1, O out, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Rng , typename C = less, typename P = identity> requires input_range<Rng> && indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>> && indirectly_copyable_storable<iterator_t<Rng>, range_value_t<Rng> *>
constexpr range_value_t< Rng > | ranges::min (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename T , typename C = less, typename P = identity> requires copyable<T> && indirect_strict_weak_order<C, projected<T const *, P>>
constexpr T | ranges::min (std::initializer_list< T > const &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename T , typename C = less, typename P = identity> requires indirect_strict_weak_order<C, projected<T const *, P>>
constexpr T const & | ranges::min (T const &a, T const &b, C pred=C{}, P proj=P{})
| function template `min`
template<typename I , typename S , typename C = less, typename P = identity> requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<C, projected<I, P>>
constexpr I | ranges::min_element (I first, S last, C pred=C{}, P proj=P{})
| function template `min_element`
template<typename Rng , typename C = less, typename P = identity> requires forward_range<Rng> && indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>>
constexpr borrowed_iterator_t< Rng > | ranges::min_element (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Rng , typename C = less, typename P = identity> requires input_range<Rng> && indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>> && indirectly_copyable_storable<iterator_t<Rng>, range_value_t<Rng> *>
constexpr minmax_result< range_value_t< Rng > > | ranges::minmax (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename T , typename C = less, typename P = identity> requires copyable<T> && indirect_strict_weak_order<C, projected<T const *, P>>
constexpr minmax_result< T > | ranges::minmax (std::initializer_list< T > const &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename T , typename C = less, typename P = identity> requires indirect_strict_weak_order<C, projected<T const *, P>>
constexpr minmax_result< T const & > | ranges::minmax (T const &a, T const &b, C pred=C{}, P proj=P{})
| function template `minmax`
template<typename I , typename S , typename C = less, typename P = identity> requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<C, projected<I, P>>
constexpr minmax_element_result< I > | ranges::minmax_element (I first, S last, C pred=C{}, P proj=P{})
| function template `minmax_element`
template<typename Rng , typename C = less, typename P = identity> requires forward_range<Rng> && indirect_strict_weak_order<C, projected<iterator_t<Rng>, P>>
constexpr minmax_element_result< borrowed_iterator_t< Rng > > | ranges::minmax_element (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I1 , typename S1 , typename I2 , typename C = equal_to, typename P1 = identity, typename P2 = identity> requires input_iterator<I1> && sentinel_for<S1, I1> && input_iterator<I2> && indirect_relation<C, projected<I1, P1>, projected<I2, P2>>
mismatch_result< I1, I2 > | ranges::mismatch (I1 begin1, S1 end1, I2 begin2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| function template `mismatch`
template<typename I1 , typename S1 , typename I2 , typename S2 , typename C = equal_to, typename P1 = identity, typename P2 = identity> requires input_iterator<I1> && sentinel_for<S1, I1> && input_iterator<I2> && sentinel_for<S2, I2> && indirect_relation<C, projected<I1, P1>, projected<I2, P2>>
constexpr mismatch_result< I1, I2 > | ranges::mismatch (I1 begin1, S1 end1, I2 begin2, S2 end2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Rng1 , typename I2Ref , typename C = equal_to, typename P1 = identity, typename P2 = identity> requires input_range<Rng1> && input_iterator<uncvref_t<I2Ref>> && indirect_relation<C, projected<iterator_t<Rng1>, P1>, projected<uncvref_t<I2Ref>, P2>>
mismatch_result< borrowed_iterator_t< Rng1 >, uncvref_t< I2Ref > > | ranges::mismatch (Rng1 &&rng1, I2Ref &&begin2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Rng1 , typename Rng2 , typename C = equal_to, typename P1 = identity, typename P2 = identity> requires input_range<Rng1> && input_range<Rng2> && indirect_relation<C, projected<iterator_t<Rng1>, P1>, projected<iterator_t<Rng2>, P2>>
constexpr mismatch_result< borrowed_iterator_t< Rng1 >, borrowed_iterator_t< Rng2 > > | ranges::mismatch (Rng1 &&rng1, Rng2 &&rng2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename O > requires input_iterator<I> && sentinel_for<S, I> && weakly_incrementable<O> && indirectly_movable<I, O>
constexpr move_result< I, O > | ranges::move (I first, S last, O out)
| function template `move`
template<typename Rng , typename O > requires input_range<Rng> && weakly_incrementable<O> && indirectly_movable<iterator_t<Rng>, O>
constexpr move_result< borrowed_iterator_t< Rng >, O > | ranges::move (Rng &&rng, O out)
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename O > requires bidirectional_iterator<I> && sentinel_for<S, I> && bidirectional_iterator<O> && indirectly_movable<I, O>
constexpr move_backward_result< I, O > | ranges::move_backward (I first, S end_, O out)
| function template `move_backward`
template<typename Rng , typename O > requires bidirectional_range<Rng> && bidirectional_iterator<O> && indirectly_movable<iterator_t<Rng>, O>
constexpr move_backward_result< borrowed_iterator_t< Rng >, O > | ranges::move_backward (Rng &&rng, O out)
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C = less, typename P = identity> requires bidirectional_iterator<I> && sentinel_for<S, I> && sortable<I, C, P>
constexpr bool | ranges::next_permutation (I first, S end_, C pred=C{}, P proj=P{})
| function template `next_permutation`
template<typename Rng , typename C = less, typename P = identity> requires bidirectional_range<Rng> && sortable<iterator_t<Rng>, C, P>
constexpr bool | ranges::next_permutation (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename F , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<F, projected<I, P>>
constexpr bool | ranges::none_of (I first, S last, F pred, P proj=P{})
| function template `none_of`
template<typename Rng , typename F , typename P = identity> requires input_range<Rng> && indirect_unary_predicate<F, projected<iterator_t<Rng>, P>>
constexpr bool | ranges::none_of (Rng &&rng, F pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C = less, typename P = identity> requires random_access_iterator<I> && sortable<I, C, P>
constexpr I | ranges::nth_element (I first, I nth, S end_, C pred=C{}, P proj=P{})
| function template `nth_element`
template<typename Rng , typename C = less, typename P = identity> requires random_access_range<Rng> && sortable<iterator_t<Rng>, C, P>
constexpr borrowed_iterator_t< Rng > | ranges::nth_element (Rng &&rng, iterator_t< Rng > nth, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C = less, typename P = identity> requires sortable<I, C, P> && random_access_iterator<I> && sentinel_for<S, I>
constexpr I | ranges::partial_sort (I first, I middle, S last, C pred=C{}, P proj=P{})
| function template `partial_sort`
template<typename Rng , typename C = less, typename P = identity> requires sortable<iterator_t<Rng>, C, P> && random_access_range<Rng>
constexpr borrowed_iterator_t< Rng > | ranges::partial_sort (Rng &&rng, iterator_t< Rng > middle, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename SI , typename O , typename SO , typename C = less, typename PI = identity, typename PO = identity> requires input_iterator<I> && sentinel_for<SI, I> && random_access_iterator<O> && sentinel_for<SO, O> && indirectly_copyable<I, O> && sortable<O, C, PO> && indirect_strict_weak_order<C, projected<I, PI>, projected<O, PO>>
constexpr O | ranges::partial_sort_copy (I first, SI last, O out_begin, SO out_end, C pred=C{}, PI in_proj=PI{}, PO out_proj=PO{})
| function template `partial_sort_copy`
template<typename InRng , typename OutRng , typename C = less, typename PI = identity, typename PO = identity> requires input_range<InRng> && random_access_range<OutRng> && indirectly_copyable<iterator_t<InRng>, iterator_t<OutRng>> && sortable<iterator_t<OutRng>, C, PO> && indirect_strict_weak_order<C, projected<iterator_t<InRng>, PI>, projected<iterator_t<OutRng>, PO>>
constexpr borrowed_iterator_t< OutRng > | ranges::partial_sort_copy (InRng &&in_rng, OutRng &&out_rng, C pred=C{}, PI in_proj=PI{}, PO out_proj=PO{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C , typename P = identity> requires permutable<I> && sentinel_for<S, I> && indirect_unary_predicate<C, projected<I, P>>
constexpr I | ranges::partition (I first, S last, C pred, P proj=P{})
| function template `partition`
template<typename Rng , typename C , typename P = identity> requires forward_range<Rng> && permutable<iterator_t<Rng>> && indirect_unary_predicate<C, projected<iterator_t<Rng>, P>>
constexpr borrowed_iterator_t< Rng > | ranges::partition (Rng &&rng, C pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename O0 , typename O1 , typename C , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && weakly_incrementable<O0> && weakly_incrementable<O1> && indirectly_copyable<I, O0> && indirectly_copyable<I, O1> && indirect_unary_predicate<C, projected<I, P>>
constexpr partition_copy_result< I, O0, O1 > | ranges::partition_copy (I first, S last, O0 o0, O1 o1, C pred, P proj=P{})
| function template `partition_copy`
template<typename Rng , typename O0 , typename O1 , typename C , typename P = identity> requires input_range<Rng> && weakly_incrementable<O0> && weakly_incrementable<O1> && indirectly_copyable<iterator_t<Rng>, O0> && indirectly_copyable<iterator_t<Rng>, O1> && indirect_unary_predicate<C, projected<iterator_t<Rng>, P>>
constexpr partition_copy_result< borrowed_iterator_t< Rng >, O0, O1 > | ranges::partition_copy (Rng &&rng, O0 o0, O1 o1, C pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C , typename P = identity> requires forward_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<C, projected<I, P>>
constexpr I | ranges::partition_point (I first, S last, C pred, P proj=P{})
| function template `partition_point`
template<typename Rng , typename C , typename P = identity> requires forward_range<Rng> && indirect_unary_predicate<C, projected<iterator_t<Rng>, P>>
constexpr borrowed_iterator_t< Rng > | ranges::partition_point (Rng &&rng, C pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C = less, typename P = identity> requires random_access_iterator<I> && sentinel_for<S, I> && sortable<I, C, P>
constexpr I | ranges::pop_heap (I first, S last, C pred=C{}, P proj=P{})
| function template `pop_heap`
template<typename Rng , typename C = less, typename P = identity> requires random_access_range<Rng> && sortable<iterator_t<Rng>, C, P>
constexpr borrowed_iterator_t< Rng > | ranges::pop_heap (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C = less, typename P = identity> requires bidirectional_iterator<I> && sentinel_for<S, I> && sortable<I, C, P>
constexpr bool | ranges::prev_permutation (I first, S end_, C pred=C{}, P proj=P{})
| function template `prev_permutation`
template<typename Rng , typename C = less, typename P = identity> requires bidirectional_range<Rng> && sortable<iterator_t<Rng>, C, P>
constexpr bool | ranges::prev_permutation (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C = less, typename P = identity> requires random_access_iterator<I> && sentinel_for<S, I> && sortable<I, C, P>
constexpr I | ranges::push_heap (I first, S last, C pred=C{}, P proj=P{})
| function template `push_heap`
template<typename Rng , typename C = less, typename P = identity> requires random_access_range<Rng> && sortable<iterator_t<Rng>, C, P>
constexpr borrowed_iterator_t< Rng > | ranges::push_heap (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename T , typename P = identity> requires permutable<I> && sentinel_for<S, I> && indirect_relation<equal_to, projected<I, P>, T const *>
constexpr I | ranges::remove (I first, S last, T const &val, P proj=P{})
| function template `remove`
template<typename Rng , typename T , typename P = identity> requires forward_range<Rng> && permutable<iterator_t<Rng>> && indirect_relation<equal_to, projected<iterator_t<Rng>, P>, T const *>
constexpr borrowed_iterator_t< Rng > | ranges::remove (Rng &&rng, T const &val, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename O , typename T , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && weakly_incrementable<O> && indirect_relation<equal_to, projected<I, P>, T const *> && indirectly_copyable<I, O>
constexpr remove_copy_result< I, O > | ranges::remove_copy (I first, S last, O out, T const &val, P proj=P{})
| function template `remove_copy`
template<typename Rng , typename O , typename T , typename P = identity> requires input_range<Rng> && weakly_incrementable<O> && indirect_relation<equal_to, projected<iterator_t<Rng>, P>, T const *> && indirectly_copyable<iterator_t<Rng>, O>
constexpr remove_copy_result< borrowed_iterator_t< Rng >, O > | ranges::remove_copy (Rng &&rng, O out, T const &val, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename O , typename C , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && weakly_incrementable<O> && indirect_unary_predicate<C, projected<I, P>> && indirectly_copyable<I, O>
constexpr remove_copy_if_result< I, O > | ranges::remove_copy_if (I first, S last, O out, C pred, P proj=P{})
| function template `remove_copy_if`
template<typename Rng , typename O , typename C , typename P = identity> requires input_range<Rng> && weakly_incrementable<O> && indirect_unary_predicate<C, projected<iterator_t<Rng>, P>> && indirectly_copyable<iterator_t<Rng>, O>
constexpr remove_copy_if_result< borrowed_iterator_t< Rng >, O > | ranges::remove_copy_if (Rng &&rng, O out, C pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C , typename P = identity> requires permutable<I> && sentinel_for<S, I> && indirect_unary_predicate<C, projected<I, P>>
constexpr I | ranges::remove_if (I first, S last, C pred, P proj=P{})
| function template `remove_if`
template<typename Rng , typename C , typename P = identity> requires forward_range<Rng> && permutable<iterator_t<Rng>> && indirect_unary_predicate<C, projected<iterator_t<Rng>, P>>
constexpr borrowed_iterator_t< Rng > | ranges::remove_if (Rng &&rng, C pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename T1 , typename T2 , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && indirectly_writable<I, T2 const &> && indirect_relation<equal_to, projected<I, P>, T1 const *>
constexpr I | ranges::replace (I first, S last, T1 const &old_value, T2 const &new_value, P proj={})
| function template `replace`
template<typename Rng , typename T1 , typename T2 , typename P = identity> requires input_range<Rng> && indirectly_writable<iterator_t<Rng>, T2 const &> && indirect_relation<equal_to, projected<iterator_t<Rng>, P>, T1 const *>
constexpr borrowed_iterator_t< Rng > | ranges::replace (Rng &&rng, T1 const &old_value, T2 const &new_value, P proj={})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename O , typename T1 , typename T2 , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && output_iterator<O, T2 const &> && indirectly_copyable<I, O> && indirect_relation<equal_to, projected<I, P>, T1 const *>
constexpr replace_copy_result< I, O > | ranges::replace_copy (I first, S last, O out, T1 const &old_value, T2 const &new_value, P proj={})
| function template `replace_copy`
template<typename Rng , typename O , typename T1 , typename T2 , typename P = identity> requires input_range<Rng> && output_iterator<O, T2 const &> && indirectly_copyable<iterator_t<Rng>, O> && indirect_relation<equal_to, projected<iterator_t<Rng>, P>, T1 const *>
constexpr replace_copy_result< borrowed_iterator_t< Rng >, O > | ranges::replace_copy (Rng &&rng, O out, T1 const &old_value, T2 const &new_value, P proj={})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename O , typename C , typename T , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && output_iterator<O, T const &> && indirect_unary_predicate<C, projected<I, P>> && indirectly_copyable<I, O>
constexpr replace_copy_if_result< I, O > | ranges::replace_copy_if (I first, S last, O out, C pred, T const &new_value, P proj={})
| function template `replace_copy_if`
template<typename Rng , typename O , typename C , typename T , typename P = identity> requires input_range<Rng> && output_iterator<O, T const &> && indirect_unary_predicate<C, projected<iterator_t<Rng>, P>> && indirectly_copyable<iterator_t<Rng>, O>
constexpr replace_copy_if_result< borrowed_iterator_t< Rng >, O > | ranges::replace_copy_if (Rng &&rng, O out, C pred, T const &new_value, P proj={})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C , typename T , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<C, projected<I, P>> && indirectly_writable<I, T const &>
constexpr I | ranges::replace_if (I first, S last, C pred, T const &new_value, P proj=P{})
| function template `replace_if`
template<typename Rng , typename C , typename T , typename P = identity> requires input_range<Rng> && indirect_unary_predicate<C, projected<iterator_t<Rng>, P>> && indirectly_writable<iterator_t<Rng>, T const &>
constexpr borrowed_iterator_t< Rng > | ranges::replace_if (Rng &&rng, C pred, T const &new_value, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S > requires bidirectional_iterator<I> && sentinel_for<S, I> && permutable<I>
constexpr I | ranges::reverse (I first, S end_)
| function template `reverse`
template<typename Rng , typename I = iterator_t<Rng>> requires bidirectional_range<Rng> && permutable<I>
constexpr borrowed_iterator_t< Rng > | ranges::reverse (Rng &&rng)
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename O > requires bidirectional_iterator<I> && sentinel_for<S, I> && weakly_incrementable<O> && indirectly_copyable<I, O>
constexpr reverse_copy_result< I, O > | ranges::reverse_copy (I first, S end_, O out)
| function template `reverse_copy`
template<typename Rng , typename O > requires bidirectional_range<Rng> && weakly_incrementable<O> && indirectly_copyable<iterator_t<Rng>, O>
constexpr reverse_copy_result< borrowed_iterator_t< Rng >, O > | ranges::reverse_copy (Rng &&rng, O out)
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S > requires permutable<I> && sentinel_for<S, I>
constexpr subrange< I > | ranges::rotate (I first, I middle, S last)
| function template `rotate`
template<typename Rng , typename I = iterator_t<Rng>> requires range<Rng> && permutable<I>
constexpr borrowed_subrange_t< Rng > | ranges::rotate (Rng &&rng, I middle)
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename O , typename P = identity> requires forward_iterator<I> && sentinel_for<S, I> && weakly_incrementable<O> && indirectly_copyable<I, O>
constexpr rotate_copy_result< I, O > | ranges::rotate_copy (I first, I middle, S last, O out)
| function template `rotate_copy`
template<typename Rng , typename O , typename P = identity> requires range<Rng> && weakly_incrementable<O> && indirectly_copyable<iterator_t<Rng>, O>
constexpr rotate_copy_result< borrowed_iterator_t< Rng >, O > | ranges::rotate_copy (Rng &&rng, iterator_t< Rng > middle, O out)
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename O , typename Gen = detail::default_random_engine &> requires input_iterator<I> && sentinel_for<S, I> && weakly_incrementable<O> && indirectly_copyable<I, O> && uniform_random_bit_generator<std::remove_reference_t<Gen>> && (random_access_iterator<O> || forward_iterator<I> || sized_sentinel_for<S, I>)
sample_result< I, O > | ranges::sample (I first, S last, O out, iter_difference_t< O > const n, Gen &&gen=detail::get_random_engine())
| function template `sample`

template<typename I , typename S , typename ORng , typename Gen = detail::default_random_engine &>
requires input_iterator<I> && sentinel_for<S, I> && weakly_incrementable<iterator_t<ORng>> && indirectly_copyable<I, iterator_t<ORng>> && uniform_random_bit_generator<std::remove_reference_t<Gen>> && (forward_range<ORng> || sized_range<ORng>) && (random_access_iterator<iterator_t<ORng>> || forward_iterator<I> || sized_sentinel_for<S, I>)

sample_result< I, borrowed_iterator_t< ORng > > | ranges::sample (I first, S last, ORng &&out, Gen &&gen=detail::get_random_engine())
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename IRng , typename ORng , typename Gen = detail::default_random_engine &> requires input_range<IRng> && range<ORng> && indirectly_copyable<iterator_t<IRng>, iterator_t<ORng>> && uniform_random_bit_generator<std::remove_reference_t<Gen>> && (random_access_iterator<iterator_t<ORng>> || forward_range<IRng> || sized_range<IRng>) && (forward_range<ORng> || sized_range<ORng>)
sample_result< borrowed_iterator_t< IRng >, borrowed_iterator_t< ORng > > | ranges::sample (IRng &&rng, ORng &&out, Gen &&gen=detail::get_random_engine())
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Rng , typename O , typename Gen = detail::default_random_engine &> requires input_range<Rng> && weakly_incrementable<O> && indirectly_copyable<iterator_t<Rng>, O> && uniform_random_bit_generator<std::remove_reference_t<Gen>> && (random_access_iterator<O> || forward_range<Rng> || sized_range<Rng>)
sample_result< borrowed_iterator_t< Rng >, O > | ranges::sample (Rng &&rng, O out, iter_difference_t< O > const n, Gen &&gen=detail::get_random_engine())
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I1 , typename S1 , typename I2 , typename S2 , typename C = equal_to, typename P1 = identity, typename P2 = identity> requires forward_iterator<I1> && sentinel_for<S1, I1> && forward_iterator<I2> && sentinel_for<S2, I2> && indirectly_comparable<I1, I2, C, P1, P2>
constexpr subrange< I1 > | ranges::search (I1 begin1, S1 end1, I2 begin2, S2 end2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| function template `search`
template<typename Rng1 , typename Rng2 , typename C = equal_to, typename P1 = identity, typename P2 = identity> requires forward_range<Rng1> && forward_range<Rng2> && indirectly_comparable<iterator_t<Rng1>, iterator_t<Rng2>, C, P1, P2>
constexpr borrowed_subrange_t< Rng1 > | ranges::search (Rng1 &&rng1, Rng2 &&rng2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename V , typename C = equal_to, typename P = identity> requires forward_iterator<I> && sentinel_for<S, I> && indirectly_comparable<I, V const *, C, P>
constexpr subrange< I > | ranges::search_n (I first, S last, iter_difference_t< I > cnt, V const &val, C pred=C{}, P proj=P{})
| function template `search_n`
template<typename Rng , typename V , typename C = equal_to, typename P = identity> requires forward_range<Rng> && indirectly_comparable<iterator_t<Rng>, V const *, C, P>
constexpr borrowed_subrange_t< Rng > | ranges::search_n (Rng &&rng, iter_difference_t< iterator_t< Rng > > cnt, V const &val, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I1 , typename S1 , typename I2 , typename S2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> requires sentinel_for<S1, I1> && sentinel_for<S2, I2> && mergeable<I1, I2, O, C, P1, P2>
constexpr set_difference_result< I1, O > | ranges::set_difference (I1 begin1, S1 end1, I2 begin2, S2 end2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| function template `set_difference`
template<typename Rng1 , typename Rng2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> requires range<Rng1> && range<Rng2> && mergeable<iterator_t<Rng1>, iterator_t<Rng2>, O, C, P1, P2>
constexpr set_difference_result< borrowed_iterator_t< Rng1 >, O > | ranges::set_difference (Rng1 &&rng1, Rng2 &&rng2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I1 , typename S1 , typename I2 , typename S2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> requires sentinel_for<S1, I1> && sentinel_for<S2, I2> && mergeable<I1, I2, O, C, P1, P2>
constexpr O | ranges::set_intersection (I1 begin1, S1 end1, I2 begin2, S2 end2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| function template `set_intersection`
template<typename Rng1 , typename Rng2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> requires range<Rng1> && range<Rng2> && mergeable<iterator_t<Rng1>, iterator_t<Rng2>, O, C, P1, P2>
constexpr O | ranges::set_intersection (Rng1 &&rng1, Rng2 &&rng2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I1 , typename S1 , typename I2 , typename S2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> requires sentinel_for<S1, I1> && sentinel_for<S2, I2> && mergeable<I1, I2, O, C, P1, P2>
constexpr set_symmetric_difference_result< I1, I2, O > | ranges::set_symmetric_difference (I1 begin1, S1 end1, I2 begin2, S2 end2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| function template `set_symmetric_difference`
template<typename Rng1 , typename Rng2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> requires range<Rng1> && range<Rng2> && mergeable<iterator_t<Rng1>, iterator_t<Rng2>, O, C, P1, P2>
constexpr set_symmetric_difference_result< borrowed_iterator_t< Rng1 >, borrowed_iterator_t< Rng2 >, O > | ranges::set_symmetric_difference (Rng1 &&rng1, Rng2 &&rng2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I1 , typename S1 , typename I2 , typename S2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> requires sentinel_for<S1, I1> && sentinel_for<S2, I2> && mergeable<I1, I2, O, C, P1, P2>
constexpr set_union_result< I1, I2, O > | ranges::set_union (I1 begin1, S1 end1, I2 begin2, S2 end2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| function template `set_union`
template<typename Rng1 , typename Rng2 , typename O , typename C = less, typename P1 = identity, typename P2 = identity> requires range<Rng1> && range<Rng2> && mergeable<iterator_t<Rng1>, iterator_t<Rng2>, O, C, P1, P2>
constexpr set_union_result< borrowed_iterator_t< Rng1 >, borrowed_iterator_t< Rng2 >, O > | ranges::set_union (Rng1 &&rng1, Rng2 &&rng2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename Gen = detail::default_random_engine &> requires random_access_iterator<I> && sentinel_for<S, I> && permutable<I> && uniform_random_bit_generator<std::remove_reference_t<Gen>> && convertible_to<invoke_result_t<Gen &>, iter_difference_t<I>>
I | ranges::shuffle (I const first, S const last, Gen &&gen=detail::get_random_engine())
| function template `shuffle`
template<typename Rng , typename Gen = detail::default_random_engine &> requires random_access_range<Rng> && permutable<iterator_t<Rng>> && uniform_random_bit_generator<std::remove_reference_t<Gen>> && convertible_to<invoke_result_t<Gen &>, iter_difference_t<iterator_t<Rng>>>
borrowed_iterator_t< Rng > | ranges::shuffle (Rng &&rng, Gen &&rand=detail::get_random_engine())
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C = less, typename P = identity> requires sortable<I, C, P> && random_access_iterator<I> && sentinel_for<S, I>
constexpr I | ranges::sort (I first, S end_, C pred=C{}, P proj=P{})
| function template `sort`
template<typename Rng , typename C = less, typename P = identity> requires sortable<iterator_t<Rng>, C, P> && random_access_range<Rng>
constexpr borrowed_iterator_t< Rng > | ranges::sort (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C = less, typename P = identity> requires random_access_iterator<I> && sentinel_for<S, I> && sortable<I, C, P>
constexpr I | ranges::sort_heap (I first, S last, C pred=C{}, P proj=P{})
template<typename Rng , typename C = less, typename P = identity> requires random_access_range<Rng &> && sortable<iterator_t<Rng>, C, P>
constexpr borrowed_iterator_t< Rng > | ranges::sort_heap (Rng &&rng, C pred=C{}, P proj=P{})
template<typename I , typename S , typename C , typename P = identity> requires bidirectional_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<C, projected<I, P>> && permutable<I>
I | ranges::stable_partition (I first, S last, C pred, P proj=P{})
| function template `stable_partition`
template<typename Rng , typename C , typename P = identity> requires bidirectional_range<Rng> && indirect_unary_predicate<C, projected<iterator_t<Rng>, P>> && permutable<iterator_t<Rng>>
borrowed_iterator_t< Rng > | ranges::stable_partition (Rng &&rng, C pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C = less, typename P = identity> requires sortable<I, C, P> && random_access_iterator<I> && sentinel_for<S, I>
I | ranges::stable_sort (I first, S end_, C pred=C{}, P proj=P{})
| function template `stable_sort`
template<typename Rng , typename C = less, typename P = identity> requires sortable<iterator_t<Rng>, C, P> && random_access_range<Rng>
borrowed_iterator_t< Rng > | ranges::stable_sort (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I1 , typename S1 , typename I2 , typename S2 , typename Comp = equal_to, typename Proj1 = identity, typename Proj2 = identity> requires input_iterator<I1> && sentinel_for<S1, I1> && input_iterator<I2> && sentinel_for<S2, I2> && indirectly_comparable<I1, I2, Comp, Proj1, Proj2>
constexpr bool | ranges::starts_with (I1 first1, S1 last1, I2 first2, S2 last2, Comp comp={}, Proj1 proj1={}, Proj2 proj2={})
| function template `starts_with`
template<typename R1 , typename R2 , typename Comp = equal_to, typename Proj1 = identity, typename Proj2 = identity> requires input_range<R1> && input_range<R2> && indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Comp, Proj1, Proj2>
constexpr bool | ranges::starts_with (R1 &&r1, R2 &&r2, Comp comp={}, Proj1 proj1={}, Proj2 proj2={})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I1 , typename S1 , typename I2 > requires input_iterator<I1> && sentinel_for<S1, I1> && input_iterator<I2> && indirectly_swappable<I1, I2>
constexpr swap_ranges_result< I1, I2 > | ranges::swap_ranges (I1 begin1, S1 end1, I2 begin2)
| function template `swap_ranges`
template<typename I1 , typename S1 , typename I2 , typename S2 > requires input_iterator<I1> && sentinel_for<S1, I1> && input_iterator<I2> && sentinel_for<S2, I2> && indirectly_swappable<I1, I2>
constexpr swap_ranges_result< I1, I2 > | ranges::swap_ranges (I1 begin1, S1 end1, I2 begin2, S2 end2)
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Rng1 , typename I2_ > requires input_range<Rng1> && input_iterator<uncvref_t<I2_>> && indirectly_swappable<iterator_t<Rng1>, uncvref_t<I2_>>
constexpr swap_ranges_result< iterator_t< Rng1 >, uncvref_t< I2_ > > | ranges::swap_ranges (Rng1 &&rng1, I2_ &&begin2)
template<typename Rng1 , typename Rng2 > requires input_range<Rng1> && input_range<Rng2> && indirectly_swappable<iterator_t<Rng1>, iterator_t<Rng2>>
constexpr swap_ranges_result< borrowed_iterator_t< Rng1 >, borrowed_iterator_t< Rng2 > > | ranges::swap_ranges (Rng1 &&rng1, Rng2 &&rng2)
template<typename I , typename S , typename O , typename F , typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && weakly_incrementable<O> && copy_constructible<F> && indirectly_writable<O, indirect_result_t<F &, projected<I, P>>>
constexpr unary_transform_result< I, O > | ranges::transform (I first, S last, O out, F fun, P proj=P{})
| function template `transform`
template<typename I0 , typename S0 , typename I1 , typename O , typename F , typename P0 = identity, typename P1 = identity> requires input_iterator<I0> && sentinel_for<S0, I0> && input_iterator<I1> && weakly_incrementable<O> && copy_constructible<F> && indirectly_writable< O, indirect_result_t<F &, projected<I0, P0>, projected<I1, P1>>>
binary_transform_result< I0, I1, O > | ranges::transform (I0 begin0, S0 end0, I1 begin1, O out, F fun, P0 proj0=P0{}, P1 proj1=P1{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I0 , typename S0 , typename I1 , typename S1 , typename O , typename F , typename P0 = identity, typename P1 = identity> requires input_iterator<I0> && sentinel_for<S0, I0> && input_iterator<I1> && sentinel_for<S1, I1> && weakly_incrementable<O> && copy_constructible<F> && indirectly_writable< O, indirect_result_t<F &, projected<I0, P0>, projected<I1, P1>>>
constexpr binary_transform_result< I0, I1, O > | ranges::transform (I0 begin0, S0 end0, I1 begin1, S1 end1, O out, F fun, P0 proj0=P0{}, P1 proj1=P1{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Rng , typename O , typename F , typename P = identity> requires input_range<Rng> && weakly_incrementable<O> && copy_constructible<F> && indirectly_writable<O, indirect_result_t<F &, projected<iterator_t<Rng>, P>>>
constexpr unary_transform_result< borrowed_iterator_t< Rng >, O > | ranges::transform (Rng &&rng, O out, F fun, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Rng0 , typename I1Ref , typename O , typename F , typename P0 = identity, typename P1 = identity> requires input_range<Rng0> && input_iterator<uncvref_t<I1Ref>> && weakly_incrementable<O> && copy_constructible<F> && indirectly_writable< O, indirect_result_t<F &, projected<iterator_t<Rng0>, P0>, projected<uncvref_t<I1Ref>, P1>>>
binary_transform_result< borrowed_iterator_t< Rng0 >, uncvref_t< I1Ref >, O > | ranges::transform (Rng0 &&rng0, I1Ref &&begin1, O out, F fun, P0 proj0=P0{}, P1 proj1=P1{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Rng0 , typename Rng1 , typename O , typename F , typename P0 = identity, typename P1 = identity> requires input_range<Rng0> && input_range<Rng1> && weakly_incrementable<O> && copy_constructible<F> && indirectly_writable< O, indirect_result_t<F &, projected<iterator_t<Rng0>, P0>, projected<iterator_t<Rng1>, P1>>>
constexpr binary_transform_result< borrowed_iterator_t< Rng0 >, borrowed_iterator_t< Rng1 >, O > | ranges::transform (Rng0 &&rng0, Rng1 &&rng1, O out, F fun, P0 proj0=P0{}, P1 proj1=P1{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename C = equal_to, typename P = identity> requires sortable<I, C, P> && sentinel_for<S, I>
constexpr I | ranges::unique (I first, S last, C pred=C{}, P proj=P{})
| template function `unique`
template<typename Rng , typename C = equal_to, typename P = identity> requires sortable<iterator_t<Rng>, C, P> && range<Rng>
constexpr borrowed_iterator_t< Rng > | ranges::unique (Rng &&rng, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename O , typename C = equal_to, typename P = identity> requires input_iterator<I> && sentinel_for<S, I> && indirect_relation<C, projected<I, P>> && weakly_incrementable<O> && indirectly_copyable<I, O> && (forward_iterator<I> || forward_iterator<O> || indirectly_copyable_storable<I, O>)
constexpr unique_copy_result< I, O > | ranges::unique_copy (I first, S last, O out, C pred=C{}, P proj=P{})
| template function unique_copy
template<typename Rng , typename O , typename C = equal_to, typename P = identity> requires input_range<Rng> && indirect_relation<C, projected<iterator_t<Rng>, P>> && weakly_incrementable<O> && indirectly_copyable<iterator_t<Rng>, O> && (forward_iterator<iterator_t<Rng>> || forward_iterator<O> || indirectly_copyable_storable<iterator_t<Rng>, O>)
constexpr unique_copy_result< borrowed_iterator_t< Rng >, O > | ranges::unique_copy (Rng &&rng, O out, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename C , typename P = identity> requires bidirectional_iterator<I> && permutable<I> && indirect_unary_predicate<C, projected<I, P>>
constexpr I | ranges::unstable_remove_if (I first, I last, C pred, P proj={})
| unstable_remove have O(1) complexity for each element remove, unlike remove O(n) [for worst case]. Each erased element overwritten (moved in) with last one. unstable_remove_if does not preserve relative element order.
template<typename Rng , typename C , typename P = identity> requires bidirectional_range<Rng> && common_range<Rng> && permutable<iterator_t<Rng>> && indirect_unary_predicate<C, projected<iterator_t<Rng>, P>>
constexpr borrowed_iterator_t< Rng > | ranges::unstable_remove_if (Rng &&rng, C pred, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename I , typename S , typename V , typename C = less, typename P = identity> requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<C, V const *, projected<I, P>>
constexpr I | ranges::upper_bound (I first, S last, V const &val, C pred=C{}, P proj=P{})
| function template `upper_bound`
template<typename Rng , typename V , typename C = less, typename P = identity> requires forward_range<Rng> && indirect_strict_weak_order<C, V const *, projected<iterator_t<Rng>, P>>
constexpr borrowed_iterator_t< Rng > | ranges::upper_bound (Rng &&rng, V const &val, C pred=C{}, P proj=P{})
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## Detailed Description

Iterator- and range-based algorithms, like the standard algorithms.

## Function Documentation

## adjacent_find()

template<typename I , typename S , typename C = equal_to, typename P = identity>
requires forward_iterator<I> && sentinel_for<S, I> && indirect_relation<C, projected<I, P>>

constexpr I ranges::adjacent_find | ( | I | first,
|  | S | last,
|  | C | pred = `C{}`,
|  | P | proj = `P{}`
| ) |  |

constexpr

`#include <range/v3/algorithm/adjacent_find.hpp>`

function template `adjacent_find`

range-based version of the `adjacent_find` std algorithm

Precondition
  `Rng` is a model of the `range` concept
  `C` is a model of the `BinaryPredicate` concept

## adjacent_remove_if()

template<typename I , typename S , typename Pred , typename Proj = identity>
requires permutable<I> && sentinel_for<S, I> && indirect_relation<Pred, projected<I, Proj>>

constexpr I ranges::adjacent_remove_if | ( | I | first,
|  | S | last,
|  | Pred | pred = `{}`,
|  | Proj | proj = `{}`
| ) |  |

constexpr

`#include <range/v3/algorithm/adjacent_remove_if.hpp>`

function `adjacent_remove_if`

range-based version of the `adjacent_remove_if` algorithm

Precondition
  `Rng` is a model of the `forward_range` concept.
  `Pred` is a model of the `BinaryPredicate` concept.

## binary_search()

template<typename I , typename S , typename V , typename C = less, typename P = identity>
requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<C, V const *, projected<I, P>>

constexpr bool ranges::binary_search | ( | I | first,
|  | S | last,
|  | V const & | val,
|  | C | pred = `C{}`,
|  | P | proj = `P{}`
| ) |  |

constexpr

`#include <range/v3/algorithm/binary_search.hpp>`

function template `binary_search`

range-based version of the `binary_search` std algorithm

Precondition
  `Rng` is a model of the `range` concept

## find()

template<typename I , typename S , typename V , typename P = identity>
requires input_iterator<I> && sentinel_for<S, I> && indirect_relation<equal_to, projected<I, P>, V const *>

constexpr I ranges::find | ( | I | first,
|  | S | last,
|  | V const & | val,
|  | P | proj = `P{}`
| ) |  |

constexpr

`#include <range/v3/algorithm/find.hpp>`

template function `find`

range-based version of the `find` std algorithm

Precondition
  `Rng` is a model of the `range` concept
  `I` is a model of the `input_iterator` concept
  `S` is a model of the `sentinel_for<I>` concept
  `P` is a model of the `invocable<iter_common_reference_t<I>>` concept
  The ResultType of `P` is equality_comparable with V

## find_if()

template<typename I , typename S , typename F , typename P = identity>
requires input_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<F, projected<I, P>>

constexpr I ranges::find_if | ( | I | first,
|  | S | last,
|  | F | pred,
|  | P | proj = `P{}`
| ) |  |

constexpr

`#include <range/v3/algorithm/find_if.hpp>`

template function `find`

range-based version of the `find` std algorithm

Precondition
  `Rng` is a model of the `range` concept
  `I` is a model of the `input_iterator` concept
  `S` is a model of the `sentinel_for<I>` concept
  `P` is a model of the `invocable<V>` concept, where `V` is the value type of I.
  `F` models `predicate<X>`, where `X` is the result type of `invocable<P, V>`

## find_if_not()

template<typename I , typename S , typename F , typename P = identity>
requires input_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<F, projected<I, P>>

constexpr I ranges::find_if_not | ( | I | first,
|  | S | last,
|  | F | pred,
|  | P | proj = `P{}`
| ) |  |

constexpr

`#include <range/v3/algorithm/find_if_not.hpp>`

template function `find_if_not`

range-based version of the `find_if_not` std algorithm

Precondition
  `Rng` is a model of the `range` concept
  `I` is a model of the `input_iterator` concept
  `S` is a model of the `sentinel_for<I>` concept
  `P` is a model of the `invocable<V>` concept, where `V` is the value type of I.
  `F` models `predicate<X>`, where `X` is the result type of `invocable<P, V>`

## is_sorted()

template<typename I , typename S , typename R = less, typename P = identity>
requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<R, projected<I, P>>

constexpr bool ranges::is_sorted | ( | I | first,
|  | S | last,
|  | R | rel = `R{}`,
|  | P | proj = `P{}`
| ) |  |

constexpr

`#include <range/v3/algorithm/is_sorted.hpp>`

template function `is_sorted`

range-based version of the `is_sorted` std algorithm

Works on forward_ranges

Precondition
  `Rng` is a model of the `forward_range` concept
  `I` is a model of the `forward_iterator` concept
  `S` and `I` model the `sentinel_for<S, I>` concept
  `R` and `projected<I, P>` model the `indirect_strict_weak_order<R, projected<I, P>>` concept

## is_sorted_until()

template<typename I , typename S , typename R = less, typename P = identity>
requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<R, projected<I, P>>

constexpr I ranges::is_sorted_until | ( | I | first,
|  | S | last,
|  | R | pred = `R{}`,
|  | P | proj = `P{}`
| ) |  |

constexpr

`#include <range/v3/algorithm/is_sorted_until.hpp>`

template function `is_sorted_until`

range-based version of the `is_sorted_until` std algorithm

Works on forward_ranges

Precondition
  `Rng` is a model of the `forward_range` concept
  `I` is a model of the `forward_iterator` concept
  `S` and `I` model the `sentinel_for<S, I>` concept
  `R` and `projected<I, P>` model the `indirect_strict_weak_order<R, projected<I, P>>` concept

## unique()

template<typename I , typename S , typename C = equal_to, typename P = identity>
requires sortable<I, C, P> && sentinel_for<S, I>

constexpr I ranges::unique | ( | I | first,
|  | S | last,
|  | C | pred = `C{}`,
|  | P | proj = `P{}`
| ) |  |

constexpr

`#include <range/v3/algorithm/unique.hpp>`

template function `unique`

range-based version of the `unique` std algorithm

Precondition
  `Rng` is a model of the `forward_range` concept
  `I` is a model of the `forward_iterator` concept
  `S` is a model of the `sentinel_for` concept
  `C` is a model of the `relation` concept

## unique_copy()

template<typename I , typename S , typename O , typename C = equal_to, typename P = identity>
requires input_iterator<I> && sentinel_for<S, I> && indirect_relation<C, projected<I, P>> && weakly_incrementable<O> && indirectly_copyable<I, O> && (forward_iterator<I> || forward_iterator<O> || indirectly_copyable_storable<I, O>)

constexpr unique_copy_result< I, O > ranges::unique_copy | ( | I | first,
|  | S | last,
|  | O | out,
|  | C | pred = `C{}`,
|  | P | proj = `P{}`
| ) |  |

constexpr

`#include <range/v3/algorithm/unique_copy.hpp>`

template function unique_copy

range-based version of the `unique_copy` std algorithm

Precondition
  `Rng` is a model of the `input_range` concept
  `O` is a model of the `weakly_incrementable` concept
  `C` is a model of the `relation` concept

## unstable_remove_if()

template<typename I , typename C , typename P = identity>
requires bidirectional_iterator<I> && permutable<I> && indirect_unary_predicate<C, projected<I, P>>

constexpr I ranges::unstable_remove_if | ( | I | first,
|  | I | last,
|  | C | pred,
|  | P | proj = `{}`
| ) |  |

constexpr

`#include <range/v3/algorithm/unstable_remove_if.hpp>`

unstable_remove have O(1) complexity for each element remove, unlike remove O(n) [for worst case]. Each erased element overwritten (moved in) with last one. unstable_remove_if does not preserve relative element order.

function template `unstable_remove_if`