Horizon
Classes | Typedefs | Functions | Variables
Algorithms

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

Classes

struct  ranges::copy_fn
 
struct  ranges::move_fn
 

Typedefs

template<typename I , typename O >
using ranges::copy_result = detail::in_out_result< I, 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 F >
using ranges::for_each_result = detail::in_fun_result< I, F >
 
template<typename O , typename F >
using ranges::generate_result = detail::out_fun_result< O, F >
 
template<typename O , typename F >
using ranges::generate_n_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 T >
using ranges::minmax_result = detail::min_max_result< T, T >
 
template<typename I >
using ranges::minmax_element_result = detail::min_max_result< I, I >
 
template<typename I1 , typename I2 >
using ranges::mismatch_result = detail::in1_in2_result< I1, I2 >
 
template<typename I , typename O >
using ranges::move_result = detail::in_out_result< I, O >
 
template<typename I , typename O >
using ranges::move_backward_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_result = detail::in_out_result< I, O >
 
template<typename I , typename O >
using ranges::remove_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::replace_copy_if_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 I1 , typename I2 , typename O >
using ranges::set_union_result = detail::in1_in2_out_result< I1, I2, 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 >
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 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::unique_copy_result = detail::in_out_result< I, O >
 

Functions

 ranges::template (typename I, typename S, typename C=equal_to, typename P=identity)(requires forward_iterator< I > AND sentinel_for< S
 function template adjacent_find More...
 
I AND constexpr indirect_relation< C, projected< I, P > > I RANGES_FUNC() ranges::adjacent_find (I first, S last, C pred=C{}, P proj=P{})
 
 ranges::template (typename Rng, typename C=equal_to, typename P=identity)(requires forward_range< Rng > AND indirect_relation< C
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr projected< iterator_t< Rng >, P > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::adjacent_find (Rng &&rng, C pred=C{}, P proj=P{})
 
 ranges::template (typename I, typename S, typename Pred, typename Proj=identity)(requires permutable< I > AND sentinel_for< S
 function adjacent_remove_if More...
 
I AND constexpr indirect_relation< Pred, projected< I, Proj > > I RANGES_FUNC() ranges::adjacent_remove_if (I first, S last, Pred pred={}, Proj proj={})
 
 ranges::template (typename Rng, typename Pred, typename Proj=identity)(requires forward_range< Rng > AND indirect_relation< Pred
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
projected< iterator_t< Rng >, Proj > AND constexpr permutable< iterator_t< Rng > > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::adjacent_remove_if (Rng &&rng, Pred pred, Proj proj={})
 
 ranges::template (typename I, typename S, typename F, typename P=identity)(requires input_iterator< I > AND sentinel_for< S
 function template all_of More...
 
I AND constexpr indirect_unary_predicate< F, projected< I, P > > bool RANGES_FUNC() ranges::all_of (I first, S last, F pred, P proj=P{})
 
 ranges::template (typename Rng, typename F, typename P=identity)(requires input_range< Rng > AND indirect_unary_predicate< F
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr projected< iterator_t< Rng >, P > bool RANGES_FUNC() ranges::all_of (Rng &&rng, F pred, P proj=P{})
 
I AND constexpr indirect_unary_predicate< F, projected< I, P > > bool RANGES_FUNC() ranges::any_of (I first, S last, F pred, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > bool RANGES_FUNC() ranges::any_of (Rng &&rng, F pred, P proj=P{})
 
 ranges::template (typename I, typename S, typename V, typename C=less, typename P=identity)(requires forward_iterator< I > AND sentinel_for< S
 function template binary_search More...
 
I AND constexpr indirect_strict_weak_order< C, V const *, projected< I, P > > bool RANGES_FUNC() ranges::binary_search (I first, S last, V const &val, C pred=C{}, P proj=P{})
 
 ranges::template (typename Rng, typename V, typename C=less, typename P=identity)(requires forward_range< Rng > AND indirect_strict_weak_order< C
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
V const constexpr projected< iterator_t< Rng >, P > bool RANGES_FUNC() ranges::binary_search (Rng &&rng, V const &val, C pred=C{}, P proj=P{})
 
 ranges::template (typename I, typename S, typename T, typename P=identity)(requires input_iterator< I > AND sentinel_for< S
 function template contains More...
 
I AND constexpr indirect_relation< equal_to, projected< I, P >, const T * > bool RANGES_FUNC() ranges::contains (I first, S last, const T &val, P proj={})
 
 ranges::template (typename Rng, typename T, typename P=identity)(requires input_range< Rng > AND indirect_relation< equal_to
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const T *constexpr bool RANGES_FUNC() ranges::contains (Rng &&rng, const T &val, P proj={})
 
 ranges::template (typename I, typename S, typename O)(requires input_iterator< I > AND sentinel_for< S
 function template copy More...
 
I AND weakly_incrementable< O > AND constexpr indirectly_copyable< I, O > copy_result< I, O > RANGES_FUNC() ranges::copy (I first, S last, O out)
 
 ranges::template (typename Rng, typename O)(requires input_range< Rng > AND weakly_incrementable< O > AND indirectly_copyable< iterator_t< Rng >
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr O copy_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::copy (Rng &&rng, O out)
 
I AND bidirectional_iterator< O > AND constexpr indirectly_copyable< I, O > copy_backward_result< I, O > RANGES_FUNC() ranges::copy_backward (I first, S end_, O out)
 
O constexpr copy_backward_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::copy_backward (Rng &&rng, O out)
 
 ranges::template (typename I, typename S, typename O, typename F, typename P=identity)(requires input_iterator< I > AND sentinel_for< S
 function template copy_if More...
 
I AND weakly_incrementable< O > AND indirect_unary_predicate< F, projected< I, P > > AND constexpr indirectly_copyable< I, O > copy_if_result< I, O > RANGES_FUNC() ranges::copy_if (I first, S last, O out, F pred, P proj=P{})
 
 ranges::template (typename Rng, typename O, typename F, typename P=identity)(requires input_range< Rng > AND weakly_incrementable< O > AND indirect_unary_predicate< F
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
projected< iterator_t< Rng >, P > AND constexpr indirectly_copyable< iterator_t< Rng >, O > copy_if_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::copy_if (Rng &&rng, O out, F pred, P proj=P{})
 
 ranges::template (typename I, typename O, typename P=identity)(requires input_iterator< I > AND weakly_incrementable< O > AND indirectly_copyable< I
 function template copy_n
 
constexpr O copy_n_result< I, O > RANGES_FUNC() ranges::copy_n (I first, iter_difference_t< I > n, O out)
 
 ranges::template (typename I, typename S, typename V, typename P=identity)(requires input_iterator< I > AND sentinel_for< S
 function template count More...
 
I AND constexpr indirect_relation< equal_to, projected< I, P >, V const * > iter_difference_t< I > RANGES_FUNC() ranges::count (I first, S last, V const &val, P proj=P{})
 
 ranges::template (typename Rng, typename V, typename P=identity)(requires input_range< Rng > AND indirect_relation< equal_to
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
V const *constexpr iter_difference_t< iterator_t< Rng > > RANGES_FUNC() ranges::count (Rng &&rng, V const &val, P proj=P{})
 
 ranges::template (typename I, typename S, typename R, typename P=identity)(requires input_iterator< I > AND sentinel_for< S
 function template count_if More...
 
I AND constexpr indirect_unary_predicate< R, projected< I, P > > iter_difference_t< I > RANGES_FUNC() ranges::count_if (I first, S last, R pred, P proj=P{})
 
 ranges::template (typename Rng, typename R, typename P=identity)(requires input_range< Rng > AND indirect_unary_predicate< R
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr projected< iterator_t< Rng >, P > iter_difference_t< iterator_t< Rng > > RANGES_FUNC() ranges::count_if (Rng &&rng, R pred, P proj=P{})
 
 ranges::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
 function template ends_with
 
 ranges::I0 (input_iterator< I0 > &&sized_sentinel_for< S0, I0 >)) AND((forward_iterator< I1 > &&sentinel_for< S1
 
 ranges::I1 (input_iterator< I1 > &&sized_sentinel_for< S1, I1 >)) AND indirectly_comparable< I0
 
constexpr P1 bool RANGES_FUNC() ranges::ends_with (I0 begin0, S0 end0, I1 begin1, S1 end1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
 
 ranges::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 >)) AND(forward_range< Rng1 >||(input_range< Rng1 > &&sized_range< Rng1 >)) AND indirectly_comparable< iterator_t< Rng0 >
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr P1 bool RANGES_FUNC() ranges::ends_with (Rng0 &&rng0, Rng1 &&rng1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
 
 ranges::template (typename I0, typename S0, typename I1, typename C=equal_to, typename P0=identity, typename P1=identity)(requires input_iterator< I0 > AND sentinel_for< S0
 function template equal
 
I0 AND input_iterator< I1 > AND indirectly_comparable< I0, I1, C, P0, P1 > ranges::RANGES_DEPRECATED ("Use the variant of ranges::equal that takes an upper bound for " "both sequences") const expr bool RANGES_FUNC(equal)(I0 begin0
 
I AND constexpr indirect_strict_weak_order< C, V const *, projected< I, P > > subrange< I > RANGES_FUNC() ranges::equal_range (I first, S last, V const &val, C pred=C{}, P proj=P{})
 
V const constexpr projected< iterator_t< Rng >, P > borrowed_subrange_t< Rng > RANGES_FUNC() ranges::equal_range (Rng &&rng, V const &val, C pred=C{}, P proj=P{})
 
 ranges::template (typename O, typename S, typename V)(requires output_iterator< O
 function template fill
 
V const &AND constexpr sentinel_for< S, O > O RANGES_FUNC() ranges::fill (O first, S last, V const &val)
 
 ranges::template (typename Rng, typename V)(requires output_range< Rng
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
V const &constexpr borrowed_iterator_t< Rng > RANGES_FUNC() ranges::fill (Rng &&rng, V const &val)
 
 ranges::template (typename O, typename V)(requires output_iterator< O
 function template equal
 
V const &constexpr O RANGES_FUNC() ranges::fill_n (O first, iter_difference_t< O > n, V const &val)
 
I AND constexpr indirect_relation< equal_to, projected< I, P >, V const * > I RANGES_FUNC() ranges::find (I first, S last, V const &val, P proj=P{})
 
V const *constexpr borrowed_iterator_t< Rng > RANGES_FUNC() ranges::find (Rng &&rng, V const &val, P proj=P{})
 
 ranges::template (typename I1, typename S1, typename I2, typename S2, typename R=equal_to, typename P=identity)(requires forward_iterator< I1 > AND sentinel_for< S1
 function template find_end
 
I1 AND forward_iterator< I2 > AND sentinel_for< S2, I2 > AND constexpr indirect_relation< R, projected< I1, P >, I2 > subrange< I1 > RANGES_FUNC() ranges::find_end (I1 begin1, S1 end1, I2 begin2, S2 end2, R pred=R{}, P proj=P{})
 
 ranges::template (typename Rng1, typename Rng2, typename R=equal_to, typename P=identity)(requires forward_range< Rng1 > AND forward_range< Rng2 > AND indirect_relation< R
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr iterator_t< Rng2 > borrowed_subrange_t< Rng1 > RANGES_FUNC() ranges::find_end (Rng1 &&rng1, Rng2 &&rng2, R pred=R{}, P proj=P{})
 
 ranges::template (typename I0, typename S0, typename I1, typename S1, typename R=equal_to, typename P0=identity, typename P1=identity)(requires input_iterator< I0 > AND sentinel_for< S0
 function template find_first_of
 
I0 AND forward_iterator< I1 > AND sentinel_for< S1, I1 > AND constexpr indirect_relation< R, projected< I0, P0 >, projected< I1, P1 > > I0 RANGES_FUNC() ranges::find_first_of (I0 begin0, S0 end0, I1 begin1, S1 end1, R pred=R{}, P0 proj0=P0{}, P1 proj1=P1{})
 
 ranges::template (typename Rng0, typename Rng1, typename R=equal_to, typename P0=identity, typename P1=identity)(requires input_range< Rng0 > AND forward_range< Rng1 > AND indirect_relation< R
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr projected< iterator_t< Rng1 >, P1 > borrowed_iterator_t< Rng0 > RANGES_FUNC() ranges::find_first_of (Rng0 &&rng0, Rng1 &&rng1, R pred=R{}, P0 proj0=P0{}, P1 proj1=P1{})
 
I AND constexpr indirect_unary_predicate< F, projected< I, P > > I RANGES_FUNC() ranges::find_if (I first, S last, F pred, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::find_if (Rng &&rng, F pred, P proj=P{})
 
I AND constexpr indirect_unary_predicate< F, projected< I, P > > I RANGES_FUNC() ranges::find_if_not (I first, S last, F pred, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::find_if_not (Rng &&rng, F pred, P proj=P{})
 
 ranges::template (typename I, typename S, typename T, typename Op)(requires sentinel_for< S
 
I AND input_iterator< I > AND constexpr indirectly_binary_left_foldable< Op, T, I > auto RANGES_FUNC() ranges::fold_left (I first, S last, T init, Op op)
 
 ranges::template (typename Rng, typename T, typename Op)(requires input_range< Rng > AND indirectly_binary_left_foldable< Op
 
constexpr iterator_t< Rng > auto RANGES_FUNC() ranges::fold_left (Rng &&rng, T init, Op op)
 
 ranges::template (typename I, typename S, typename Op)(requires sentinel_for< S
 
I AND input_iterator< I > AND indirectly_binary_left_foldable< Op, iter_value_t< I >, I > AND constexpr constructible_from< iter_value_t< I >, iter_reference_t< I > > auto RANGES_FUNC() ranges::fold_left_first (I first, S last, Op op)
 
 ranges::template (typename R, typename Op)(requires input_range< R > AND indirectly_binary_left_foldable< Op
 
iterator_t< R > AND constexpr constructible_from< range_value_t< R >, range_reference_t< R > > auto RANGES_FUNC() ranges::fold_left_first (R &&rng, Op op)
 
I AND bidirectional_iterator< I > AND constexpr indirectly_binary_right_foldable< Op, T, I > auto RANGES_FUNC() ranges::fold_right (I first, S last, T init, Op op)
 
constexpr iterator_t< Rng > auto RANGES_FUNC() ranges::fold_right (Rng &&rng, T init, Op op)
 
I AND bidirectional_iterator< I > AND indirectly_binary_right_foldable< Op, iter_value_t< I >, I > AND constexpr constructible_from< iter_value_t< I >, iter_reference_t< I > > auto RANGES_FUNC() ranges::fold_right_last (I first, S last, Op op)
 
iterator_t< R > AND constexpr constructible_from< range_value_t< R >, range_reference_t< R > > auto RANGES_FUNC() ranges::fold_right_last (R &&rng, Op op)
 
I AND constexpr indirectly_unary_invocable< F, projected< I, P > > for_each_result< I, F > RANGES_FUNC() ranges::for_each (I first, S last, F fun, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > for_each_result< borrowed_iterator_t< Rng >, F > RANGES_FUNC() ranges::for_each (Rng &&rng, F fun, P proj=P{})
 
 ranges::template (typename I, typename F, typename P=identity)(requires input_iterator< I > AND indirectly_unary_invocable< F
 function template for_each_n
 
constexpr projected< I, P > I RANGES_FUNC() ranges::for_each_n (I first, iter_difference_t< I > n, F fun, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::for_each_n (Rng &&rng, range_difference_t< Rng > n, F fun, P proj=P{})
 
 ranges::template (typename O, typename S, typename F)(requires invocable< F & > AND output_iterator< O
 function template generate_n
 
invoke_result_t< F & > AND constexpr sentinel_for< S, O > generate_result< O, F > RANGES_FUNC() ranges::generate (O first, S last, F fun)
 
 ranges::template (typename Rng, typename F)(requires invocable< F & > AND output_range< Rng
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr invoke_result_t< F & > generate_result< borrowed_iterator_t< Rng >, F > RANGES_FUNC() ranges::generate (Rng &&rng, F fun)
 
 ranges::template (typename O, typename F)(requires invocable< F & > AND output_iterator< O
 function template generate_n
 
constexpr invoke_result_t< F & > generate_n_result< O, F > RANGES_FUNC() ranges::generate_n (O first, iter_difference_t< O > n, F fun)
 
I AND constexpr indirect_strict_weak_order< C, projected< I, P > > I RANGES_FUNC() ranges::is_heap_until (I first, S last, C pred=C{}, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::is_heap_until (Rng &&rng, C pred=C{}, P proj=P{})
 
I AND constexpr indirect_strict_weak_order< C, projected< I, P > > bool RANGES_FUNC() ranges::is_heap (I first, S last, C pred=C{}, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > bool RANGES_FUNC() ranges::is_heap (Rng &&rng, C pred=C{}, P proj=P{})
 
I AND constexpr sortable< I, C, P > I RANGES_FUNC() ranges::push_heap (I first, S last, C pred=C{}, P proj=P{})
 
constexpr P borrowed_iterator_t< Rng > RANGES_FUNC() ranges::push_heap (Rng &&rng, C pred=C{}, P proj=P{})
 
I AND constexpr sortable< I, C, P > I RANGES_FUNC() ranges::pop_heap (I first, S last, C pred=C{}, P proj=P{})
 
constexpr P borrowed_iterator_t< Rng > RANGES_FUNC() ranges::pop_heap (Rng &&rng, C pred=C{}, P proj=P{})
 
I AND constexpr sortable< I, C, P > I RANGES_FUNC() ranges::make_heap (I first, S last, C pred=C{}, P proj=P{})
 
constexpr P borrowed_iterator_t< Rng > RANGES_FUNC() ranges::make_heap (Rng &&rng, C pred=C{}, P proj=P{})
 
I AND constexpr sortable< I, C, P > I RANGES_FUNC() ranges::sort_heap (I first, S last, C pred=C{}, P proj=P{})
 
 ranges::template (typename Rng, typename C=less, typename P=identity)(requires random_access_range< Rng & > AND sortable< iterator_t< Rng >
 
constexpr P borrowed_iterator_t< Rng > RANGES_FUNC() ranges::sort_heap (Rng &&rng, C pred=C{}, P proj=P{})
 
P I RANGES_FUNC() ranges::inplace_merge (I first, I middle, S last, C pred=C{}, P proj=P{})
 
P borrowed_iterator_t< Rng > RANGES_FUNC() ranges::inplace_merge (Rng &&rng, iterator_t< Rng > middle, C pred=C{}, P proj=P{})
 
I AND constexpr indirect_unary_predicate< C, projected< I, P > > bool RANGES_FUNC() ranges::is_partitioned (I first, S last, C pred, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > bool RANGES_FUNC() ranges::is_partitioned (Rng &&rng, C pred, P proj=P{})
 
I AND constexpr indirect_strict_weak_order< R, projected< I, P > > bool RANGES_FUNC() ranges::is_sorted (I first, S last, R rel=R{}, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > bool RANGES_FUNC() ranges::is_sorted (Rng &&rng, R rel=R{}, P proj=P{})
 
I AND constexpr indirect_strict_weak_order< R, projected< I, P > > I RANGES_FUNC() ranges::is_sorted_until (I first, S last, R pred=R{}, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::is_sorted_until (Rng &&rng, R pred=R{}, P proj=P{})
 
 ranges::template (typename I0, typename S0, typename I1, typename S1, typename C=less, typename P0=identity, typename P1=identity)(requires input_iterator< I0 > AND sentinel_for< S0
 function template lexicographical_compare
 
I0 AND input_iterator< I1 > AND sentinel_for< S1, I1 > AND constexpr indirect_strict_weak_order< C, projected< I0, P0 >, projected< I1, P1 > > bool RANGES_FUNC() ranges::lexicographical_compare (I0 begin0, S0 end0, I1 begin1, S1 end1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
 
 ranges::template (typename Rng0, typename Rng1, typename C=less, typename P0=identity, typename P1=identity)(requires input_range< Rng0 > AND input_range< Rng1 > AND indirect_strict_weak_order< C
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr projected< iterator_t< Rng1 >, P1 > bool RANGES_FUNC() ranges::lexicographical_compare (Rng0 &&rng0, Rng1 &&rng1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
 
I AND constexpr indirect_strict_weak_order< C, V const *, projected< I, P > > I RANGES_FUNC() ranges::lower_bound (I first, S last, V const &val, C pred=C{}, P proj=P{})
 
V const constexpr projected< iterator_t< Rng >, P > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::lower_bound (Rng &&rng, V const &val, C pred=C{}, P proj=P{})
 
 ranges::template (typename T, typename C=less, typename P=identity)(requires indirect_strict_weak_order< C
 function template max More...
 
constexpr projected< T const *, P > T const &RANGES_FUNC() ranges::max (T const &a, T const &b, C pred=C{}, P proj=P{})
 
projected< iterator_t< Rng >, P > AND constexpr indirectly_copyable_storable< iterator_t< Rng >, range_value_t< Rng > * > range_value_t< Rng > RANGES_FUNC() ranges::max (Rng &&rng, C pred=C{}, P proj=P{})
 
constexpr projected< T const *, P > T RANGES_FUNC() ranges::max (std::initializer_list< T > const &&rng, C pred=C{}, P proj=P{})
 
I AND constexpr indirect_strict_weak_order< C, projected< I, P > > I RANGES_FUNC() ranges::max_element (I first, S last, C pred=C{}, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::max_element (Rng &&rng, C pred=C{}, P proj=P{})
 
 ranges::template (typename I0, typename S0, typename I1, typename S1, typename O, typename C=less, typename P0=identity, typename P1=identity)(requires sentinel_for< S0
 function template merge
 
I0 AND sentinel_for< S1, I1 > AND constexpr mergeable< I0, I1, O, C, P0, P1 > merge_result< I0, I1, O > RANGES_FUNC() ranges::merge (I0 begin0, S0 end0, I1 begin1, S1 end1, O out, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
 
 ranges::template (typename Rng0, typename Rng1, typename O, typename C=less, typename P0=identity, typename P1=identity)(requires range< Rng0 > AND range< Rng1 > AND mergeable< iterator_t< Rng0 >
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr P1 merge_result< borrowed_iterator_t< Rng0 >, borrowed_iterator_t< Rng1 >, O > RANGES_FUNC() ranges::merge (Rng0 &&rng0, Rng1 &&rng1, O out, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
 
constexpr projected< T const *, P > T const &RANGES_FUNC() ranges::min (T const &a, T const &b, C pred=C{}, P proj=P{})
 
projected< iterator_t< Rng >, P > AND constexpr indirectly_copyable_storable< iterator_t< Rng >, range_value_t< Rng > * > range_value_t< Rng > RANGES_FUNC() ranges::min (Rng &&rng, C pred=C{}, P proj=P{})
 
constexpr projected< T const *, P > T RANGES_FUNC() ranges::min (std::initializer_list< T > const &&rng, C pred=C{}, P proj=P{})
 
I AND constexpr indirect_strict_weak_order< C, projected< I, P > > I RANGES_FUNC() ranges::min_element (I first, S last, C pred=C{}, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::min_element (Rng &&rng, C pred=C{}, P proj=P{})
 
constexpr projected< T const *, P > minmax_result< T const & > RANGES_FUNC() ranges::minmax (T const &a, T const &b, C pred=C{}, P proj=P{})
 
projected< iterator_t< Rng >, P > AND constexpr indirectly_copyable_storable< iterator_t< Rng >, range_value_t< Rng > * > minmax_result< range_value_t< Rng > > RANGES_FUNC() ranges::minmax (Rng &&rng, C pred=C{}, P proj=P{})
 
constexpr projected< T const *, P > minmax_result< T > RANGES_FUNC() ranges::minmax (std::initializer_list< T > const &&rng, C pred=C{}, P proj=P{})
 
I AND constexpr indirect_strict_weak_order< C, projected< I, P > > minmax_element_result< I > RANGES_FUNC() ranges::minmax_element (I first, S last, C pred=C{}, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > minmax_element_result< borrowed_iterator_t< Rng > > RANGES_FUNC() ranges::minmax_element (Rng &&rng, C pred=C{}, P proj=P{})
 
 ranges::template (typename I1, typename S1, typename I2, typename C=equal_to, typename P1=identity, typename P2=identity)(requires input_iterator< I1 > AND sentinel_for< S1
 function template mismatch More...
 
I1 AND input_iterator< I2 > AND indirect_relation< C, projected< I1, P1 >, projected< I2, P2 > > ranges::RANGES_DEPRECATED ("Use the variant of ranges::mismatch that takes an upper bound for " "both sequences") mismatch_result< I1
 
I1 AND input_iterator< I2 > AND indirect_relation< C, projected< I1, P1 >, projected< I2, P2 > > I2 RANGES_FUNC() ranges::mismatch (I1 begin1, S1 end1, I2 begin2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
 ranges::template (typename I1, typename S1, typename I2, typename S2, typename C=equal_to, typename P1=identity, typename P2=identity)(requires input_iterator< I1 > AND sentinel_for< S1
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
I1 AND input_iterator< I2 > AND sentinel_for< S2, I2 > AND constexpr indirect_relation< C, projected< I1, P1 >, projected< I2, P2 > > mismatch_result< I1, I2 > RANGES_FUNC() ranges::mismatch (I1 begin1, S1 end1, I2 begin2, S2 end2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
 ranges::template (typename Rng1, typename I2Ref, typename C=equal_to, typename P1=identity, typename P2=identity)(requires input_range< Rng1 > AND input_iterator< uncvref_t< I2Ref >> AND indirect_relation< C
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
projected< uncvref_t< I2Ref >, P2 > uncvref_t< I2Ref > RANGES_FUNC() ranges::mismatch (Rng1 &&rng1, I2Ref &&begin2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
 ranges::template (typename Rng1, typename Rng2, typename C=equal_to, typename P1=identity, typename P2=identity)(requires input_range< Rng1 > AND input_range< Rng2 > AND indirect_relation< C
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr projected< iterator_t< Rng2 >, P2 > mismatch_result< borrowed_iterator_t< Rng1 >, borrowed_iterator_t< Rng2 > > RANGES_FUNC() ranges::mismatch (Rng1 &&rng1, Rng2 &&rng2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
I AND weakly_incrementable< O > AND constexpr indirectly_movable< I, O > move_result< I, O > RANGES_FUNC() ranges::move (I first, S last, O out)
 
constexpr O move_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::move (Rng &&rng, O out)
 
I AND bidirectional_iterator< O > AND constexpr indirectly_movable< I, O > move_backward_result< I, O > RANGES_FUNC() ranges::move_backward (I first, S end_, O out)
 
constexpr O move_backward_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::move_backward (Rng &&rng, O out)
 
I AND constexpr indirect_unary_predicate< F, projected< I, P > > bool RANGES_FUNC() ranges::none_of (I first, S last, F pred, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > bool RANGES_FUNC() ranges::none_of (Rng &&rng, F pred, P proj=P{})
 
constexpr P I RANGES_FUNC() ranges::nth_element (I first, I nth, S end_, C pred=C{}, P proj=P{})
 
constexpr P borrowed_iterator_t< Rng > RANGES_FUNC() ranges::nth_element (Rng &&rng, iterator_t< Rng > nth, C pred=C{}, P proj=P{})
 
P AND random_access_iterator< I > AND constexpr sentinel_for< S, I > I RANGES_FUNC() ranges::partial_sort (I first, I middle, S last, C pred=C{}, P proj=P{})
 
P AND constexpr random_access_range< Rng > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::partial_sort (Rng &&rng, iterator_t< Rng > middle, C pred=C{}, P proj=P{})
 
 ranges::template (typename I, typename SI, typename O, typename SO, typename C=less, typename PI=identity, typename PO=identity)(requires input_iterator< I > AND sentinel_for< SI
 function template partial_sort_copy
 
I AND random_access_iterator< O > AND sentinel_for< SO, O > AND indirectly_copyable< I, O > AND sortable< O, C, PO > AND constexpr indirect_strict_weak_order< C, projected< I, PI >, projected< O, PO > > O RANGES_FUNC() 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{})
 
 ranges::template (typename InRng, typename OutRng, typename C=less, typename PI=identity, typename PO=identity)(requires input_range< InRng > AND random_access_range< OutRng > AND indirectly_copyable< iterator_t< InRng >
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
iterator_t< OutRng > AND sortable< iterator_t< OutRng >, C, PO > AND constexpr indirect_strict_weak_order< C, projected< iterator_t< InRng >, PI >, projected< iterator_t< OutRng >, PO > > borrowed_iterator_t< OutRng > RANGES_FUNC() ranges::partial_sort_copy (InRng &&in_rng, OutRng &&out_rng, C pred=C{}, PI in_proj=PI{}, PO out_proj=PO{})
 
I AND constexpr indirect_unary_predicate< C, projected< I, P > > I RANGES_FUNC() ranges::partition (I first, S last, C pred, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::partition (Rng &&rng, C pred, P proj=P{})
 
 ranges::template (typename I, typename S, typename O0, typename O1, typename C, typename P=identity)(requires input_iterator< I > AND sentinel_for< S
 function template partition_copy
 
I AND weakly_incrementable< O0 > AND weakly_incrementable< O1 > AND indirectly_copyable< I, O0 > AND indirectly_copyable< I, O1 > AND constexpr indirect_unary_predicate< C, projected< I, P > > partition_copy_result< I, O0, O1 > RANGES_FUNC() ranges::partition_copy (I first, S last, O0 o0, O1 o1, C pred, P proj=P{})
 
 ranges::template (typename Rng, typename O0, typename O1, typename C, typename P=identity)(requires input_range< Rng > AND weakly_incrementable< O0 > AND weakly_incrementable< O1 > AND indirectly_copyable< iterator_t< Rng >
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
O0 AND indirectly_copyable< iterator_t< Rng >, O1 > AND constexpr indirect_unary_predicate< C, projected< iterator_t< Rng >, P > > partition_copy_result< borrowed_iterator_t< Rng >, O0, O1 > RANGES_FUNC() ranges::partition_copy (Rng &&rng, O0 o0, O1 o1, C pred, P proj=P{})
 
I AND constexpr indirect_unary_predicate< C, projected< I, P > > I RANGES_FUNC() ranges::partition_point (I first, S last, C pred, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::partition_point (Rng &&rng, C pred, P proj=P{})
 
I1 AND forward_iterator< I2 > AND indirectly_comparable< I1, I2, C, P1, P2 > ranges::RANGES_DEPRECATED ("Use the variant of ranges::is_permutation that takes an upper bound " "for both sequences") bool RANGES_FUNC(is_permutation)(I1 begin1
 
I AND constexpr indirect_relation< equal_to, projected< I, P >, T const * > I RANGES_FUNC() ranges::remove (I first, S last, T const &val, P proj=P{})
 
T const *constexpr borrowed_iterator_t< Rng > RANGES_FUNC() ranges::remove (Rng &&rng, T const &val, P proj=P{})
 
 ranges::template (typename I, typename S, typename O, typename T, typename P=identity)(requires input_iterator< I > AND sentinel_for< S
 function template remove_copy
 
I AND weakly_incrementable< O > AND indirect_relation< equal_to, projected< I, P >, T const * > AND constexpr indirectly_copyable< I, O > remove_copy_result< I, O > RANGES_FUNC() ranges::remove_copy (I first, S last, O out, T const &val, P proj=P{})
 
 ranges::template (typename Rng, typename O, typename T, typename P=identity)(requires input_range< Rng > AND weakly_incrementable< O > AND indirect_relation< equal_to
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
T const *AND constexpr indirectly_copyable< iterator_t< Rng >, O > remove_copy_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::remove_copy (Rng &&rng, O out, T const &val, P proj=P{})
 
 ranges::template (typename I, typename S, typename O, typename C, typename P=identity)(requires input_iterator< I > AND sentinel_for< S
 function template remove_copy_if More...
 
I AND weakly_incrementable< O > AND indirect_unary_predicate< C, projected< I, P > > AND constexpr indirectly_copyable< I, O > remove_copy_if_result< I, O > RANGES_FUNC() ranges::remove_copy_if (I first, S last, O out, C pred, P proj=P{})
 
 ranges::template (typename Rng, typename O, typename C, typename P=identity)(requires input_range< Rng > AND weakly_incrementable< O > AND indirect_unary_predicate< C
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
projected< iterator_t< Rng >, P > AND constexpr indirectly_copyable< iterator_t< Rng >, O > remove_copy_if_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::remove_copy_if (Rng &&rng, O out, C pred, P proj=P{})
 
I AND constexpr indirect_unary_predicate< C, projected< I, P > > I RANGES_FUNC() ranges::remove_if (I first, S last, C pred, P proj=P{})
 
constexpr projected< iterator_t< Rng >, P > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::remove_if (Rng &&rng, C pred, P proj=P{})
 
 ranges::template (typename I, typename S, typename T1, typename T2, typename P=identity)(requires input_iterator< I > AND sentinel_for< S
 function template replace
 
I AND indirectly_writable< I, T2 const & > AND constexpr indirect_relation< equal_to, projected< I, P >, T1 const * > I RANGES_FUNC() ranges::replace (I first, S last, T1 const &old_value, T2 const &new_value, P proj={})
 
 ranges::template (typename Rng, typename T1, typename T2, typename P=identity)(requires input_range< Rng > AND indirectly_writable< iterator_t< Rng >
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
T2 const &AND constexpr indirect_relation< equal_to, projected< iterator_t< Rng >, P >, T1 const * > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::replace (Rng &&rng, T1 const &old_value, T2 const &new_value, P proj={})
 
 ranges::template (typename I, typename S, typename O, typename T1, typename T2, typename P=identity)(requires input_iterator< I > AND sentinel_for< S
 function template replace_copy
 
I AND output_iterator< O, T2 const & > AND indirectly_copyable< I, O > AND constexpr indirect_relation< equal_to, projected< I, P >, T1 const * > replace_copy_result< I, O > RANGES_FUNC() ranges::replace_copy (I first, S last, O out, T1 const &old_value, T2 const &new_value, P proj={})
 
 ranges::template (typename Rng, typename O, typename T1, typename T2, typename P=identity)(requires input_range< Rng > AND output_iterator< O
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
T2 const &AND indirectly_copyable< iterator_t< Rng >, O > AND constexpr indirect_relation< equal_to, projected< iterator_t< Rng >, P >, T1 const * > replace_copy_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::replace_copy (Rng &&rng, O out, T1 const &old_value, T2 const &new_value, P proj={})
 
 ranges::template (typename I, typename S, typename O, typename C, typename T, typename P=identity)(requires input_iterator< I > AND sentinel_for< S
 function template replace_copy_if
 
I AND output_iterator< O, T const & > AND indirect_unary_predicate< C, projected< I, P > > AND constexpr indirectly_copyable< I, O > replace_copy_if_result< I, O > RANGES_FUNC() ranges::replace_copy_if (I first, S last, O out, C pred, T const &new_value, P proj={})
 
 ranges::template (typename Rng, typename O, typename C, typename T, typename P=identity)(requires input_range< Rng > AND output_iterator< O
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
T const &AND indirect_unary_predicate< C, projected< iterator_t< Rng >, P > > AND constexpr indirectly_copyable< iterator_t< Rng >, O > replace_copy_if_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::replace_copy_if (Rng &&rng, O out, C pred, T const &new_value, P proj={})
 
 ranges::template (typename I, typename S, typename C, typename T, typename P=identity)(requires input_iterator< I > AND sentinel_for< S
 function template replace_if
 
I AND indirect_unary_predicate< C, projected< I, P > > AND constexpr indirectly_writable< I, T const & > I RANGES_FUNC() ranges::replace_if (I first, S last, C pred, T const &new_value, P proj=P{})
 
 ranges::template (typename Rng, typename C, typename T, typename P=identity)(requires input_range< Rng > AND indirect_unary_predicate< C
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
projected< iterator_t< Rng >, P > AND constexpr indirectly_writable< iterator_t< Rng >, T const & > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::replace_if (Rng &&rng, C pred, T const &new_value, P proj=P{})
 
 ranges::template (typename I, typename S)(requires bidirectional_iterator< I > AND sentinel_for< S
 function template reverse More...
 
I AND constexpr permutable< I > I RANGES_FUNC() ranges::reverse (I first, S end_)
 
 ranges::template (typename Rng, typename I=iterator_t< Rng >)(requires bidirectional_range< Rng > AND permutable< I >) const expr borrowed_iterator_t< Rng > RANGES_FUNC(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.
 
I AND weakly_incrementable< O > AND constexpr indirectly_copyable< I, O > reverse_copy_result< I, O > RANGES_FUNC() ranges::reverse_copy (I first, S end_, O out)
 
constexpr O reverse_copy_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::reverse_copy (Rng &&rng, O out)
 
constexpr I subrange< I > RANGES_FUNC() ranges::rotate (I first, I middle, S last)
 
 ranges::template (typename I, typename S, typename O, typename P=identity)(requires forward_iterator< I > AND sentinel_for< S
 function template rotate_copy
 
I AND weakly_incrementable< O > AND constexpr indirectly_copyable< I, O > rotate_copy_result< I, O > RANGES_FUNC() ranges::rotate_copy (I first, I middle, S last, O out)
 
 ranges::template (typename Rng, typename O, typename P=identity)(requires range< Rng > AND weakly_incrementable< O > AND indirectly_copyable< iterator_t< Rng >
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr O rotate_copy_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::rotate_copy (Rng &&rng, iterator_t< Rng > middle, O out)
 
 ranges::template (typename I, typename S, typename O, typename Gen=detail::default_random_engine &)(requires input_iterator< I > AND sentinel_for< S
 function template sample
 
I AND weakly_incrementable< O > AND indirectly_copyable< I, O > AND uniform_random_bit_generator< std::remove_reference_t< Gen > > ranges::AND (random_access_iterator< O >||forward_iterator< I >||sized_sentinel_for< S, I >)) sample_result< I
 
I AND weakly_incrementable< O > AND indirectly_copyable< I, O > AND uniform_random_bit_generator< std::remove_reference_t< Gen > > O RANGES_FUNC() ranges::sample (I first, S last, O out, iter_difference_t< O > const n, Gen &&gen=detail::get_random_engine())
 
 ranges::template (typename I, typename S, typename ORng, typename Gen=detail::default_random_engine &)(requires input_iterator< I > AND sentinel_for< S
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
I AND weakly_incrementable< iterator_t< ORng > > AND indirectly_copyable< I, iterator_t< ORng > > AND uniform_random_bit_generator< std::remove_reference_t< Gen > > ranges::AND (forward_range< ORng >||sized_range< ORng >) AND(random_access_iterator< iterator_t< ORng >>||forward_iterator< I >||sized_sentinel_for< S
 
I AND weakly_incrementable< iterator_t< ORng > > AND indirectly_copyable< I, iterator_t< ORng > > AND uniform_random_bit_generator< std::remove_reference_t< Gen > > I sample_result< I, borrowed_iterator_t< ORng > > RANGES_FUNC() ranges::sample (I first, S last, ORng &&out, Gen &&gen=detail::get_random_engine())
 
 ranges::template (typename Rng, typename O, typename Gen=detail::default_random_engine &)(requires input_range< Rng > AND weakly_incrementable< O > AND indirectly_copyable< iterator_t< Rng >
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
O AND uniform_random_bit_generator< std::remove_reference_t< Gen > > ranges::AND (random_access_iterator< O >||forward_range< Rng >||sized_range< Rng >)) sample_result< borrowed_iterator_t< Rng >
 
O AND uniform_random_bit_generator< std::remove_reference_t< Gen > > O RANGES_FUNC() ranges::sample (Rng &&rng, O out, iter_difference_t< O > const n, Gen &&gen=detail::get_random_engine())
 
 ranges::template (typename IRng, typename ORng, typename Gen=detail::default_random_engine &)(requires input_range< IRng > AND range< ORng > AND indirectly_copyable< iterator_t< IRng >
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
iterator_t< ORng > AND uniform_random_bit_generator< std::remove_reference_t< Gen > > ranges::AND (random_access_iterator< iterator_t< ORng >>||forward_range< IRng >||sized_range< IRng >) AND(forward_range< ORng >||sized_range< ORng >)) sample_result< borrowed_iterator_t< IRng >
 
iterator_t< ORng > AND uniform_random_bit_generator< std::remove_reference_t< Gen > > borrowed_iterator_t< ORng > RANGES_FUNC() ranges::sample (IRng &&rng, ORng &&out, Gen &&gen=detail::get_random_engine())
 
I1 AND forward_iterator< I2 > AND sentinel_for< S2, I2 > AND constexpr indirectly_comparable< I1, I2, C, P1, P2 > subrange< I1 > RANGES_FUNC() ranges::search (I1 begin1, S1 end1, I2 begin2, S2 end2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
constexpr P2 borrowed_subrange_t< Rng1 > RANGES_FUNC() ranges::search (Rng1 &&rng1, Rng2 &&rng2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
I AND constexpr indirectly_comparable< I, V const *, C, P > subrange< I > RANGES_FUNC() ranges::search_n (I first, S last, iter_difference_t< I > cnt, V const &val, C pred=C{}, P proj=P{})
 
V const constexpr P borrowed_subrange_t< Rng > RANGES_FUNC() ranges::search_n (Rng &&rng, iter_difference_t< iterator_t< Rng >> cnt, V const &val, C pred=C{}, P proj=P{})
 
I1 AND input_iterator< I2 > AND sentinel_for< S2, I2 > AND constexpr indirect_strict_weak_order< C, projected< I1, P1 >, projected< I2, P2 > > bool RANGES_FUNC() ranges::includes (I1 begin1, S1 end1, I2 begin2, S2 end2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
constexpr projected< iterator_t< Rng2 >, P2 > bool RANGES_FUNC() ranges::includes (Rng1 &&rng1, Rng2 &&rng2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
 ranges::template (typename I1, typename S1, typename I2, typename S2, typename O, typename C=less, typename P1=identity, typename P2=identity)(requires sentinel_for< S1
 function template set_union More...
 
I1 AND sentinel_for< S2, I2 > AND constexpr mergeable< I1, I2, O, C, P1, P2 > set_union_result< I1, I2, O > RANGES_FUNC() ranges::set_union (I1 begin1, S1 end1, I2 begin2, S2 end2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
 ranges::template (typename Rng1, typename Rng2, typename O, typename C=less, typename P1=identity, typename P2=identity)(requires range< Rng1 > AND range< Rng2 > AND mergeable< iterator_t< Rng1 >
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr P2 set_union_result< borrowed_iterator_t< Rng1 >, borrowed_iterator_t< Rng2 >, O > RANGES_FUNC() ranges::set_union (Rng1 &&rng1, Rng2 &&rng2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
I1 AND sentinel_for< S2, I2 > AND constexpr mergeable< I1, I2, O, C, P1, P2 > O RANGES_FUNC() ranges::set_intersection (I1 begin1, S1 end1, I2 begin2, S2 end2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
constexpr P2 O RANGES_FUNC() ranges::set_intersection (Rng1 &&rng1, Rng2 &&rng2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
I1 AND sentinel_for< S2, I2 > AND constexpr mergeable< I1, I2, O, C, P1, P2 > set_difference_result< I1, O > RANGES_FUNC() ranges::set_difference (I1 begin1, S1 end1, I2 begin2, S2 end2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
constexpr P2 set_difference_result< borrowed_iterator_t< Rng1 >, O > RANGES_FUNC() ranges::set_difference (Rng1 &&rng1, Rng2 &&rng2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
I1 AND sentinel_for< S2, I2 > AND constexpr mergeable< I1, I2, O, C, P1, P2 > set_symmetric_difference_result< I1, I2, O > RANGES_FUNC() ranges::set_symmetric_difference (I1 begin1, S1 end1, I2 begin2, S2 end2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
constexpr P2 set_symmetric_difference_result< borrowed_iterator_t< Rng1 >, borrowed_iterator_t< Rng2 >, O > RANGES_FUNC() ranges::set_symmetric_difference (Rng1 &&rng1, Rng2 &&rng2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
 ranges::template (typename I, typename S, typename Gen=detail::default_random_engine &)(requires random_access_iterator< I > AND sentinel_for< S
 function template shuffle
 
I AND permutable< I > AND uniform_random_bit_generator< std::remove_reference_t< Gen > > AND convertible_to< invoke_result_t< Gen & >, iter_difference_t< I > > I RANGES_FUNC() ranges::shuffle (I const first, S const last, Gen &&gen=detail::get_random_engine())
 
 ranges::template (typename Rng, typename Gen=detail::default_random_engine &)(requires random_access_range< Rng > AND permutable< iterator_t< Rng >> AND uniform_random_bit_generator< std
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
P AND random_access_iterator< I > AND constexpr sentinel_for< S, I > I RANGES_FUNC() ranges::sort (I first, S end_, C pred=C{}, P proj=P{})
 
P AND constexpr random_access_range< Rng > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::sort (Rng &&rng, C pred=C{}, P proj=P{})
 
I AND indirect_unary_predicate< C, projected< I, P > > AND permutable< I > I RANGES_FUNC() ranges::stable_partition (I first, S last, C pred, P proj=P{})
 
projected< iterator_t< Rng >, P > AND permutable< iterator_t< Rng > > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::stable_partition (Rng &&rng, C pred, P proj=P{})
 
P AND random_access_iterator< I > AND sentinel_for< S, I > I RANGES_FUNC() ranges::stable_sort (I first, S end_, C pred=C{}, P proj=P{})
 
P AND random_access_range< Rng > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::stable_sort (Rng &&rng, C pred=C{}, P proj=P{})
 
 ranges::template (typename I1, typename S1, typename I2, typename S2, typename Comp=equal_to, typename Proj1=identity, typename Proj2=identity)(requires input_iterator< I1 > AND sentinel_for< S1
 function template starts_with
 
I1 AND input_iterator< I2 > AND sentinel_for< S2, I2 > AND constexpr indirectly_comparable< I1, I2, Comp, Proj1, Proj2 > bool RANGES_FUNC() ranges::starts_with (I1 first1, S1 last1, I2 first2, S2 last2, Comp comp={}, Proj1 proj1={}, Proj2 proj2={})
 
 ranges::template (typename R1, typename R2, typename Comp=equal_to, typename Proj1=identity, typename Proj2=identity)(requires input_range< R1 > AND input_range< R2 > AND indirectly_comparable< iterator_t< R1 >
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr Proj2 bool RANGES_FUNC() ranges::starts_with (R1 &&r1, R2 &&r2, Comp comp={}, Proj1 proj1={}, Proj2 proj2={})
 
 ranges::template (typename I1, typename S1, typename I2)(requires input_iterator< I1 > AND sentinel_for< S1
 function template swap_ranges
 
I1 AND input_iterator< I2 > AND constexpr indirectly_swappable< I1, I2 > swap_ranges_result< I1, I2 > RANGES_FUNC() ranges::swap_ranges (I1 begin1, S1 end1, I2 begin2)
 
 ranges::template (typename I1, typename S1, typename I2, typename S2)(requires input_iterator< I1 > AND sentinel_for< S1
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
I1 AND input_iterator< I2 > AND sentinel_for< S2, I2 > AND constexpr indirectly_swappable< I1, I2 > swap_ranges_result< I1, I2 > RANGES_FUNC() ranges::swap_ranges (I1 begin1, S1 end1, I2 begin2, S2 end2)
 
 ranges::template (typename Rng1, typename I2_)(requires input_range< Rng1 > AND input_iterator< uncvref_t< I2_ >> AND indirectly_swappable< iterator_t< Rng1 >
 
constexpr uncvref_t< I2_ > swap_ranges_result< iterator_t< Rng1 >, uncvref_t< I2_ > > RANGES_FUNC() ranges::swap_ranges (Rng1 &&rng1, I2_ &&begin2)
 
 ranges::template (typename Rng1, typename Rng2)(requires input_range< Rng1 > AND input_range< Rng2 > AND indirectly_swappable< iterator_t< Rng1 >
 
constexpr iterator_t< Rng2 > swap_ranges_result< borrowed_iterator_t< Rng1 >, borrowed_iterator_t< Rng2 > > RANGES_FUNC() ranges::swap_ranges (Rng1 &&rng1, Rng2 &&rng2)
 
I AND weakly_incrementable< O > AND copy_constructible< F > AND constexpr indirectly_writable< O, indirect_result_t< F &, projected< I, P > > > unary_transform_result< I, O > RANGES_FUNC() ranges::transform (I first, S last, O out, F fun, P proj=P{})
 
constexpr indirect_result_t< F &, projected< iterator_t< Rng >, P > > unary_transform_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::transform (Rng &&rng, O out, F fun, P proj=P{})
 
 ranges::template (typename I0, typename S0, typename I1, typename S1, typename O, typename F, typename P0=identity, typename P1=identity)(requires input_iterator< I0 > AND sentinel_for< S0
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
I0 AND input_iterator< I1 > AND sentinel_for< S1, I1 > AND weakly_incrementable< O > AND copy_constructible< F > AND constexpr indirectly_writable< O, indirect_result_t< F &, projected< I0, P0 >, projected< I1, P1 > > > binary_transform_result< I0, I1, O > RANGES_FUNC() ranges::transform (I0 begin0, S0 end0, I1 begin1, S1 end1, O out, F fun, P0 proj0=P0{}, P1 proj1=P1{})
 
 ranges::template (typename Rng0, typename Rng1, typename O, typename F, typename P0=identity, typename P1=identity)(requires input_range< Rng0 > AND input_range< Rng1 > AND weakly_incrementable< O > AND copy_constructible< F > AND indirectly_writable< O
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
constexpr indirect_result_t< F &, projected< iterator_t< Rng0 >, P0 >, projected< iterator_t< Rng1 >, P1 > > binary_transform_result< borrowed_iterator_t< Rng0 >, borrowed_iterator_t< Rng1 >, O > RANGES_FUNC() ranges::transform (Rng0 &&rng0, Rng1 &&rng1, O out, F fun, P0 proj0=P0{}, P1 proj1=P1{})
 
 ranges::template (typename I0, typename S0, typename I1, typename O, typename F, typename P0=identity, typename P1=identity)(requires input_iterator< I0 > AND sentinel_for< S0
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
I0 AND input_iterator< I1 > AND weakly_incrementable< O > AND copy_constructible< F > AND indirectly_writable< O, indirect_result_t< F &, projected< I0, P0 >, projected< I1, P1 > > > ranges::RANGES_DEPRECATED ("Use the variant of ranges::transform that takes an upper bound " "for both input ranges") binary_transform_result< I0
 
I0 AND input_iterator< I1 > AND weakly_incrementable< O > AND copy_constructible< F > AND indirectly_writable< O, indirect_result_t< F &, projected< I0, P0 >, projected< I1, P1 > > > O RANGES_FUNC() ranges::transform (I0 begin0, S0 end0, I1 begin1, O out, F fun, P0 proj0=P0{}, P1 proj1=P1{})
 
 ranges::template (typename Rng0, typename I1Ref, typename O, typename F, typename P0=identity, typename P1=identity)(requires input_range< Rng0 > AND input_iterator< uncvref_t< I1Ref >> AND weakly_incrementable< O > AND copy_constructible< F > AND indirectly_writable< O
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
indirect_result_t< F &, projected< iterator_t< Rng0 >, P0 >, projected< uncvref_t< I1Ref >, P1 > > O RANGES_FUNC() ranges::transform (Rng0 &&rng0, I1Ref &&begin1, O out, F fun, P0 proj0=P0{}, P1 proj1=P1{})
 
P AND constexpr sentinel_for< S, I > I RANGES_FUNC() ranges::unique (I first, S last, C pred=C{}, P proj=P{})
 
P AND constexpr range< Rng > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::unique (Rng &&rng, C pred=C{}, P proj=P{})
 
I AND indirect_relation< C, projected< I, P > > AND weakly_incrementable< O > AND indirectly_copyable< I, O > ranges::AND (forward_iterator< I >||forward_iterator< O >||indirectly_copyable_storable< I, O >)) const expr unique_copy_result< I
 
I AND indirect_relation< C, projected< I, P > > AND weakly_incrementable< O > AND indirectly_copyable< I, O > O RANGES_FUNC() ranges::unique_copy (I first, S last, O out, C pred=C{}, P proj=P{})
 
projected< iterator_t< Rng >, P > AND weakly_incrementable< O > AND indirectly_copyable< iterator_t< Rng >, O > ranges::AND (forward_iterator< iterator_t< Rng >>||forward_iterator< O >||indirectly_copyable_storable< iterator_t< Rng >, O >)) const expr unique_copy_result< borrowed_iterator_t< Rng >
 
projected< iterator_t< Rng >, P > AND weakly_incrementable< O > AND indirectly_copyable< iterator_t< Rng >, O > O RANGES_FUNC() ranges::unique_copy (Rng &&rng, O out, C pred=C{}, P proj=P{})
 
 ranges::template (typename I, typename C, typename P=identity)(requires bidirectional_iterator< I > AND permutable< I > AND indirect_unary_predicate< C
 unstable_remove have O(1) complexity for each element remove, unlike remove O(n) [for worst case]. More...
 
constexpr projected< I, P > I RANGES_FUNC() ranges::unstable_remove_if (I first, I last, C pred, P proj={})
 
constexpr projected< iterator_t< Rng >, P > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::unstable_remove_if (Rng &&rng, C pred, P proj=P{})
 
I AND constexpr indirect_strict_weak_order< C, V const *, projected< I, P > > I RANGES_FUNC() ranges::upper_bound (I first, S last, V const &val, C pred=C{}, P proj=P{})
 
V const constexpr projected< iterator_t< Rng >, P > borrowed_iterator_t< Rng > RANGES_FUNC() ranges::upper_bound (Rng &&rng, V const &val, C pred=C{}, P proj=P{})
 

Variables

 ranges::projected< iterator_t< Rng >, P >
 
 ranges::I1
 
 ranges::C
 
 ranges::P0
 
 ranges::iterator_t< Rng1 >
 
I0 AND input_iterator< I1 > AND indirectly_comparable< I0, I1, C, P0, P1 > S0 ranges::end0
 
I0 AND input_iterator< I1 > AND indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 ranges::begin1
 
I0 AND input_iterator< I1 > AND indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C ranges::pred = C{}
 
I0 AND input_iterator< I1 > AND indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C P0 ranges::proj0 = P0{}
 
 ranges::projected< iterator_t< Rng1 >, P >
 
 ranges::projected< iterator_t< Rng0 >, P0 >
 
 ranges::T
 
 ranges::range_value_t< R >
 
 ranges::O
 
 ranges::projected< iterator_t< Rng1 >, P1 >
 
I1 AND forward_iterator< I2 > AND indirectly_comparable< I1, I2, C, P1, P2 > S1 ranges::end1
 
I1 AND forward_iterator< I2 > AND indirectly_comparable< I1, I2, C, P1, P2 > S1 I2 ranges::begin2
 
I1 AND forward_iterator< I2 > AND indirectly_comparable< I1, I2, C, P1, P2 > S1 I2 C P1 ranges::proj1 = P1{}
 
ranges::middle
 
 ranges::iterator_t< Rng2 >
 
 ranges::P1
 
 ranges::iterator_t< R2 >
 
 ranges::Comp
 
 ranges::Proj1
 
indirect_result_t< F &, projected< iterator_t< Rng0 >, P0 >, projected< uncvref_t< I1Ref >, P1 > > ranges::uncvref_t< I1Ref >
 

Detailed Description

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

Function Documentation

◆ template() [1/16]

ranges::template ( typename I  ,
typename C  ,
typename P  = identity 
)

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

◆ template() [2/16]

ranges::template ( typename I  ,
typename S   
)

function template reverse

function template rotate

◆ template() [3/16]

ranges::template ( typename I  ,
typename S  ,
typename C  = equal_to,
typename P  = identity 
)

function template adjacent_find

template function unique

function template stable_sort

function template stable_partition

function template sort

function template remove_if

function template partition_point

function template partition

function template partial_sort

function template nth_element

function template minmax_element

function template min_element

function template max_element

function template is_partitioned

function template inplace_merge

function template make_heap

function template pop_heap

function template push_heap

function template is_heap

function template is_heap_until

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

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

◆ template() [4/16]

ranges::template ( typename I  ,
typename S  ,
typename F  ,
typename P  = identity 
)

function template all_of

function template none_of

function template for_each

template function find_if_not

template function find

function template any_of

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>

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>

◆ template() [5/16]

ranges::template ( typename I  ,
typename S  ,
typename O   
)

function template copy

function template reverse_copy

function template move_backward

function template move

function template copy_backward

◆ template() [6/16]

ranges::template ( typename I  ,
typename S  ,
typename O  ,
typename C  = equal_to,
typename P  = identity 
)

function template remove_copy_if

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

◆ template() [7/16]

ranges::template ( typename I  ,
typename S  ,
typename O  ,
typename F  ,
typename P  = identity 
)

function template copy_if

function template transform

◆ template() [8/16]

ranges::template ( typename I  ,
typename S  ,
typename Pred  ,
typename Proj  = identity 
)

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.

◆ template() [9/16]

ranges::template ( typename I  ,
typename S  ,
typename R  = less,
typename P  = identity 
)

function template count_if

template function is_sorted_until

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

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

◆ template() [10/16]

ranges::template ( typename I  ,
typename S  ,
typename T  ,
typename P  = identity 
)

function template contains

function template remove

◆ template() [11/16]

ranges::template ( typename I  ,
typename S  ,
typename V  ,
typename C  = less,
typename P  = identity 
)

function template binary_search

function template upper_bound

function template search_n

function template lower_bound

function template equal_range

range-based version of the binary_search std algorithm

Precondition
Rng is a model of the range concept

◆ template() [12/16]

ranges::template ( typename I  ,
typename S  ,
typename V  ,
typename P  = identity 
)

function template count

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

◆ template() [13/16]

ranges::template ( typename I1  ,
typename S1  ,
typename I2  ,
typename C  = equal_to,
typename P1  = identity,
typename P2  = identity 
)

function template mismatch

function template is_permutation

◆ template() [14/16]

ranges::template ( typename I1  ,
typename S1  ,
typename I2  ,
typename S2  ,
typename C  = equal_to,
typename P1  = identity,
typename P2  = identity 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

function template includes

function template search

◆ template() [15/16]

ranges::template ( typename I1  ,
typename S1  ,
typename I2  ,
typename S2  ,
typename O  ,
typename C  = less,
typename P1  = identity,
typename P2  = identity 
)

function template set_union

function template set_symmetric_difference

function template set_difference

function template set_intersection

◆ template() [16/16]

ranges::template ( typename T  ,
typename C  = less,
typename P  = identity 
)

function template max

function template minmax

function template min

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Variable Documentation

◆ middle

I ranges::middle
Initial value:
{
return (*this)(begin(rng), std::move(middle), end(rng))