Range-v3
Range algorithms, views, and actions for the Standard Library
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 More...
 
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 More...
 
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 More...
 
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 More...
 
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< Rng1ranges::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 More...
 
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 More...
 
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>
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 More...
 
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 More...
 
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< Rng1ranges::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>>
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>
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>
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 More...
 
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 More...
 
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. More...
 
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 ( first,
last,
pred = C{},
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 ( first,
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 ( first,
last,
V const &  val,
pred = C{},
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 ( first,
last,
V const &  val,
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 ( first,
last,
pred,
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 ( first,
last,
pred,
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 ( first,
last,
rel = R{},
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 ( first,
last,
pred = R{},
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 ( first,
last,
pred = C{},
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 ( first,
last,
out,
pred = C{},
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 ( first,
last,
pred,
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