Horizon
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Functions | Variables
Algorithms

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

Namespaces

namespace  ranges::cpp20
 

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)(AND sentinel_for< S
 function template adjacent_find
 
I AND indirect_relation< C, projected< I, P > > constexpr 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)(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< iterator_t< Rng >, P > constexpr 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)(AND sentinel_for< S
 function adjacent_remove_if
 
I AND indirect_relation< Pred, projected< I, Proj > > constexpr I RANGES_FUNC() ranges::adjacent_remove_if (I first, S last, Pred pred={}, Proj proj={})
 
 ranges::template (typename Rng, typename Pred, typename Proj=identity)(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 permutable< iterator_t< Rng > > constexpr 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)(AND sentinel_for< S
 function template all_of
 
I AND indirect_unary_predicate< F, projected< I, P > > constexpr bool RANGES_FUNC() ranges::all_of (I first, S last, F pred, P proj=P{})
 
 ranges::template (typename Rng, typename F, typename P=identity)(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 > constexpr bool RANGES_FUNC() ranges::all_of (Rng &&rng, F pred, P proj=P{})
 
I AND indirect_unary_predicate< F, projected< I, P > > constexpr bool RANGES_FUNC() ranges::any_of (I first, S last, F pred, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr 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)(AND sentinel_for< S
 function template binary_search
 
I AND indirect_strict_weak_order< C, V const *, projected< I, P > > constexpr 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)(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 projected< iterator_t< Rng >, P > constexpr 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)(AND sentinel_for< S
 function template contains
 
I AND indirect_relation< equal_to, projected< I, P >, const T * > constexpr bool RANGES_FUNC() ranges::contains (I first, S last, const T &val, P proj={})
 
 ranges::template (typename Rng, typename T, typename P=identity)(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)(AND sentinel_for< S
 function template copy
 
I AND weakly_incrementable< O > AND indirectly_copyable< I, O > constexpr copy_result< I, O > RANGES_FUNC() ranges::copy (I first, S last, O out)
 
 ranges::template (typename Rng, typename O)(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 constexpr copy_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::copy (Rng &&rng, O out)
 
I AND bidirectional_iterator< O > AND indirectly_copyable< I, O > constexpr copy_backward_result< I, O > RANGES_FUNC() ranges::copy_backward (I first, S end_, O out)
 
O copy_backward_result< borrowed_iterator_t< Rng >, O > constexpr RANGES_FUNC() ranges::copy_backward (Rng &&rng, O out)
 
 ranges::template (typename I, typename S, typename O, typename F, typename P=identity)(AND sentinel_for< S
 function template copy_if
 
I AND weakly_incrementable< O > AND indirect_unary_predicate< F, projected< I, P > > AND indirectly_copyable< I, O > constexpr 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)(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 indirectly_copyable< iterator_t< Rng >, O > constexpr 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)(AND weakly_incrementable< O > AND indirectly_copyable< I
 function template copy_n
 
O constexpr 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)(AND sentinel_for< S
 function template count
 
I AND indirect_relation< equal_to, projected< I, P >, V const * > constexpr 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)(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)(AND sentinel_for< S
 function template count_if
 
I AND indirect_unary_predicate< R, projected< I, P > > constexpr 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)(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.
 
projected< iterator_t< Rng >, P > constexpr 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)(AND((forward_iterator< I1 > &&sentinel_for< S1
 function template ends_with
 
 ranges::I1 (input_iterator< I1 > &&sized_sentinel_for< S1, I1 >)) AND indirectly_comparable< I0
 
P1 constexpr 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)(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.
 
P1 constexpr 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)(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 indirect_strict_weak_order< C, V const *, projected< I, P > > constexpr subrange< I > RANGES_FUNC() ranges::equal_range (I first, S last, V const &val, C pred=C{}, P proj=P{})
 
V const projected< iterator_t< Rng >, P > constexpr 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)(AND sentinel_for< S
 function template fill
 
O constexpr O RANGES_FUNC() ranges::fill (O first, S last, V const &val)
 
 ranges::template (typename Rng, typename V)() const expr borrowed_iterator_t< Rng > RANGES_FUNC(fill)(Rng &&rng
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
 ranges::template (typename O, typename V)() const expr O RANGES_FUNC(fill_n)(O first
 function template equal
 
 ranges::for (;n !=0;++b, --n) *b
 
return ranges::recounted (first, b, norig)
 
I AND indirect_relation< equal_to, projected< I, P >, V const * > constexpr 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)(AND sentinel_for< S1
 function template find_end
 
I1 AND forward_iterator< I2 > AND sentinel_for< S2, I2 > AND indirect_relation< R, projected< I1, P >, I2 > constexpr 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)(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.
 
iterator_t< Rng2 > constexpr 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)(AND sentinel_for< S0
 function template find_first_of
 
I0 AND forward_iterator< I1 > AND sentinel_for< S1, I1 > AND indirect_relation< R, projected< I0, P0 >, projected< I1, P1 > > constexpr 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)(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.
 
projected< iterator_t< Rng1 >, P1 > constexpr 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 indirect_unary_predicate< F, projected< I, P > > constexpr I RANGES_FUNC() ranges::find_if (I first, S last, F pred, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr borrowed_iterator_t< Rng > RANGES_FUNC() ranges::find_if (Rng &&rng, F pred, P proj=P{})
 
I AND indirect_unary_predicate< F, projected< I, P > > constexpr I RANGES_FUNC() ranges::find_if_not (I first, S last, F pred, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr 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)(AND input_iterator< I > AND indirectly_binary_left_foldable< Op
 
I constexpr auto RANGES_FUNC() ranges::fold_left (I first, S last, T init, Op op)
 
 ranges::template (typename Rng, typename T, typename Op)(AND indirectly_binary_left_foldable< Op
 
iterator_t< Rng > constexpr auto RANGES_FUNC() ranges::fold_left (Rng &&rng, T init, Op op)
 
 ranges::template (typename I, typename S, typename Op)(AND input_iterator< I > AND indirectly_binary_left_foldable< Op
 
I AND constructible_from< iter_value_t< I >, iter_reference_t< I > > constexpr auto RANGES_FUNC() ranges::fold_left_first (I first, S last, Op op)
 
 ranges::template (typename R, typename Op)(AND indirectly_binary_left_foldable< Op
 
iterator_t< R > AND constructible_from< range_value_t< R >, range_reference_t< R > > constexpr auto RANGES_FUNC() ranges::fold_left_first (R &&rng, Op op)
 
I constexpr auto RANGES_FUNC() ranges::fold_right (I first, S last, T init, Op op)
 
iterator_t< Rng > constexpr auto RANGES_FUNC() ranges::fold_right (Rng &&rng, T init, Op op)
 
I AND constructible_from< iter_value_t< I >, iter_reference_t< I > > constexpr auto RANGES_FUNC() ranges::fold_right_last (I first, S last, Op op)
 
iterator_t< R > AND constructible_from< range_value_t< R >, range_reference_t< R > > constexpr auto RANGES_FUNC() ranges::fold_right_last (R &&rng, Op op)
 
I AND indirectly_unary_invocable< F, projected< I, P > > constexpr for_each_result< I, F > RANGES_FUNC() ranges::for_each (I first, S last, F fun, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr 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)(AND indirectly_unary_invocable< F
 function template for_each_n
 
projected< I, P > constexpr I RANGES_FUNC() ranges::for_each_n (I first, iter_difference_t< I > n, F fun, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr 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)(AND output_iterator< O
 function template generate_n
 
invoke_result_t< F & > AND sentinel_for< S, O > constexpr generate_result< O, F > RANGES_FUNC() ranges::generate (O first, S last, F fun)
 
 ranges::template (typename Rng, typename 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.
 
invoke_result_t< F & > constexpr generate_result< borrowed_iterator_t< Rng >, F > RANGES_FUNC() ranges::generate (Rng &&rng, F fun)
 
 ranges::template (typename O, typename F)(AND output_iterator< O
 function template generate_n
 
invoke_result_t< F & > constexpr generate_n_result< O, F > RANGES_FUNC() ranges::generate_n (O first, iter_difference_t< O > n, F fun)
 
I AND indirect_strict_weak_order< C, projected< I, P > > constexpr I RANGES_FUNC() ranges::is_heap_until (I first, S last, C pred=C{}, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr borrowed_iterator_t< Rng > RANGES_FUNC() ranges::is_heap_until (Rng &&rng, C pred=C{}, P proj=P{})
 
I AND indirect_strict_weak_order< C, projected< I, P > > constexpr bool RANGES_FUNC() ranges::is_heap (I first, S last, C pred=C{}, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr bool RANGES_FUNC() ranges::is_heap (Rng &&rng, C pred=C{}, P proj=P{})
 
I AND sortable< I, C, P > constexpr I RANGES_FUNC() ranges::push_heap (I first, S last, C pred=C{}, P proj=P{})
 
P constexpr borrowed_iterator_t< Rng > RANGES_FUNC() ranges::push_heap (Rng &&rng, C pred=C{}, P proj=P{})
 
I AND sortable< I, C, P > constexpr I RANGES_FUNC() ranges::pop_heap (I first, S last, C pred=C{}, P proj=P{})
 
P constexpr borrowed_iterator_t< Rng > RANGES_FUNC() ranges::pop_heap (Rng &&rng, C pred=C{}, P proj=P{})
 
I AND sortable< I, C, P > constexpr I RANGES_FUNC() ranges::make_heap (I first, S last, C pred=C{}, P proj=P{})
 
P constexpr borrowed_iterator_t< Rng > RANGES_FUNC() ranges::make_heap (Rng &&rng, C pred=C{}, P proj=P{})
 
I AND sortable< I, C, P > constexpr I RANGES_FUNC() ranges::sort_heap (I first, S last, C pred=C{}, P proj=P{})
 
P constexpr 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 indirect_unary_predicate< C, projected< I, P > > constexpr bool RANGES_FUNC() ranges::is_partitioned (I first, S last, C pred, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr bool RANGES_FUNC() ranges::is_partitioned (Rng &&rng, C pred, P proj=P{})
 
I AND indirect_strict_weak_order< R, projected< I, P > > constexpr bool RANGES_FUNC() ranges::is_sorted (I first, S last, R rel=R{}, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr bool RANGES_FUNC() ranges::is_sorted (Rng &&rng, R rel=R{}, P proj=P{})
 
I AND indirect_strict_weak_order< R, projected< I, P > > constexpr I RANGES_FUNC() ranges::is_sorted_until (I first, S last, R pred=R{}, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr 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)(AND sentinel_for< S0
 function template lexicographical_compare
 
I0 AND input_iterator< I1 > AND sentinel_for< S1, I1 > AND indirect_strict_weak_order< C, projected< I0, P0 >, projected< I1, P1 > > constexpr 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)(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.
 
projected< iterator_t< Rng1 >, P1 > constexpr bool RANGES_FUNC() ranges::lexicographical_compare (Rng0 &&rng0, Rng1 &&rng1, C pred=C{}, P0 proj0=P0{}, P1 proj1=P1{})
 
I AND indirect_strict_weak_order< C, V const *, projected< I, P > > constexpr I RANGES_FUNC() ranges::lower_bound (I first, S last, V const &val, C pred=C{}, P proj=P{})
 
V const projected< iterator_t< Rng >, P > constexpr 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)() const expr T const &RANGES_FUNC(max)(T const &a
 function template max
 
I AND indirect_strict_weak_order< C, projected< I, P > > constexpr I RANGES_FUNC() ranges::max_element (I first, S last, C pred=C{}, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr 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)(AND sentinel_for< S1
 function template merge
 
I1 AND mergeable< I0, I1, O, C, P0, P1 > constexpr 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)(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.
 
P1 constexpr 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{})
 
I AND indirect_strict_weak_order< C, projected< I, P > > constexpr I RANGES_FUNC() ranges::min_element (I first, S last, C pred=C{}, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr borrowed_iterator_t< Rng > RANGES_FUNC() ranges::min_element (Rng &&rng, C pred=C{}, P proj=P{})
 
I AND indirect_strict_weak_order< C, projected< I, P > > constexpr minmax_element_result< I > RANGES_FUNC() ranges::minmax_element (I first, S last, C pred=C{}, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr 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)(AND sentinel_for< S1
 function template mismatch
 
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)(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 indirect_relation< C, projected< I1, P1 >, projected< I2, P2 > > constexpr 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)(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)(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.
 
projected< iterator_t< Rng2 >, P2 > constexpr 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 indirectly_movable< I, O > constexpr move_result< I, O > RANGES_FUNC() ranges::move (I first, S last, O out)
 
O constexpr move_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::move (Rng &&rng, O out)
 
I AND bidirectional_iterator< O > AND indirectly_movable< I, O > constexpr move_backward_result< I, O > RANGES_FUNC() ranges::move_backward (I first, S end_, O out)
 
O constexpr move_backward_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::move_backward (Rng &&rng, O out)
 
I AND indirect_unary_predicate< F, projected< I, P > > constexpr bool RANGES_FUNC() ranges::none_of (I first, S last, F pred, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr bool RANGES_FUNC() ranges::none_of (Rng &&rng, F pred, P proj=P{})
 
P constexpr I RANGES_FUNC() ranges::nth_element (I first, I nth, S end_, C pred=C{}, P proj=P{})
 
P constexpr borrowed_iterator_t< Rng > RANGES_FUNC() ranges::nth_element (Rng &&rng, iterator_t< Rng > nth, C pred=C{}, P proj=P{})
 
I constexpr I RANGES_FUNC() ranges::partial_sort (I first, I middle, S last, C pred=C{}, P proj=P{})
 
 ranges::template (typename Rng, typename C=less, typename P=identity)(AND random_access_range< Rng >) const expr borrowed_iterator_t< Rng > RANGES_FUNC(partial_sort)(Rng &&rng
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
 ranges::template (typename I, typename SI, typename O, typename SO, typename C=less, typename PI=identity, typename PO=identity)(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 indirect_strict_weak_order< C, projected< I, PI >, projected< O, PO > > constexpr 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)(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 indirect_strict_weak_order< C, projected< iterator_t< InRng >, PI >, projected< iterator_t< OutRng >, PO > > constexpr 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 indirect_unary_predicate< C, projected< I, P > > constexpr I RANGES_FUNC() ranges::partition (I first, S last, C pred, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr 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)(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 indirect_unary_predicate< C, projected< I, P > > constexpr 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)(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 indirect_unary_predicate< C, projected< iterator_t< Rng >, P > > constexpr 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 indirect_unary_predicate< C, projected< I, P > > constexpr I RANGES_FUNC() ranges::partition_point (I first, S last, C pred, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr 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 indirect_relation< equal_to, projected< I, P >, T const * > constexpr 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)(AND sentinel_for< S
 function template remove_copy
 
I AND weakly_incrementable< O > AND indirect_relation< equal_to, projected< I, P >, T const * > AND indirectly_copyable< I, O > constexpr 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)(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 indirectly_copyable< iterator_t< Rng >, O > constexpr 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)(AND sentinel_for< S
 function template remove_copy_if
 
I AND weakly_incrementable< O > AND indirect_unary_predicate< C, projected< I, P > > AND indirectly_copyable< I, O > constexpr 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)(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 indirectly_copyable< iterator_t< Rng >, O > constexpr 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 indirect_unary_predicate< C, projected< I, P > > constexpr I RANGES_FUNC() ranges::remove_if (I first, S last, C pred, P proj=P{})
 
projected< iterator_t< Rng >, P > constexpr 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)(AND sentinel_for< S
 function template replace
 
I AND indirectly_writable< I, T2 const & > AND indirect_relation< equal_to, projected< I, P >, T1 const * > constexpr 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)(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 indirect_relation< equal_to, projected< iterator_t< Rng >, P >, T1 const * > constexpr 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)(AND sentinel_for< S
 function template replace_copy
 
I AND output_iterator< O, T2 const & > AND indirectly_copyable< I, O > AND indirect_relation< equal_to, projected< I, P >, T1 const * > constexpr 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)(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 indirect_relation< equal_to, projected< iterator_t< Rng >, P >, T1 const * > constexpr 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)(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 indirectly_copyable< I, O > constexpr 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)(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 indirectly_copyable< iterator_t< Rng >, O > constexpr 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)(AND sentinel_for< S
 function template replace_if
 
I AND indirect_unary_predicate< C, projected< I, P > > AND indirectly_writable< I, T const & > constexpr 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)(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 indirectly_writable< iterator_t< Rng >, T const & > constexpr 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)(AND sentinel_for< S
 function template reverse
 
I AND permutable< I > constexpr I RANGES_FUNC() ranges::reverse (I first, S end_)
 
 ranges::template (typename Rng, typename I=iterator_t< 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 indirectly_copyable< I, O > constexpr reverse_copy_result< I, O > RANGES_FUNC() ranges::reverse_copy (I first, S end_, O out)
 
O constexpr reverse_copy_result< borrowed_iterator_t< Rng >, O > RANGES_FUNC() ranges::reverse_copy (Rng &&rng, O out)
 
I constexpr subrange< I > RANGES_FUNC() ranges::rotate (I first, I middle, S last)
 
 ranges::template (typename I, typename S, typename O, typename P=identity)(AND sentinel_for< S
 function template rotate_copy
 
I AND weakly_incrementable< O > AND indirectly_copyable< I, O > constexpr 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)(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 constexpr 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 &)(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 &)(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 &)(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 &)(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 indirectly_comparable< I1, I2, C, P1, P2 > constexpr subrange< I1 > RANGES_FUNC() ranges::search (I1 begin1, S1 end1, I2 begin2, S2 end2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
P2 constexpr borrowed_subrange_t< Rng1 > RANGES_FUNC() ranges::search (Rng1 &&rng1, Rng2 &&rng2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
I AND indirectly_comparable< I, V const *, C, P > constexpr 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 P constexpr 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 indirect_strict_weak_order< C, projected< I1, P1 >, projected< I2, P2 > > constexpr bool RANGES_FUNC() ranges::includes (I1 begin1, S1 end1, I2 begin2, S2 end2, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
projected< iterator_t< Rng2 >, P2 > constexpr 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)(AND sentinel_for< S2
 function template set_union
 
I2 AND mergeable< I1, I2, O, C, P1, P2 > constexpr 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)(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.
 
P2 constexpr 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{})
 
I2 AND mergeable< I1, I2, O, C, P1, P2 > constexpr 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{})
 
P2 constexpr O RANGES_FUNC() ranges::set_intersection (Rng1 &&rng1, Rng2 &&rng2, O out, C pred=C{}, P1 proj1=P1{}, P2 proj2=P2{})
 
I2 AND mergeable< I1, I2, O, C, P1, P2 > constexpr 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{})
 
P2 constexpr 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{})
 
I2 AND mergeable< I1, I2, O, C, P1, P2 > constexpr 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{})
 
P2 constexpr 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 &)(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 &)(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.
 
I constexpr I RANGES_FUNC() ranges::sort (I first, S end_, 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{})
 
I I RANGES_FUNC() ranges::stable_sort (I first, S end_, 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)(AND sentinel_for< S1
 function template starts_with
 
I1 AND input_iterator< I2 > AND sentinel_for< S2, I2 > AND indirectly_comparable< I1, I2, Comp, Proj1, Proj2 > constexpr 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)(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.
 
Proj2 constexpr bool RANGES_FUNC() ranges::starts_with (R1 &&r1, R2 &&r2, Comp comp={}, Proj1 proj1={}, Proj2 proj2={})
 
 ranges::template (typename I1, typename S1, typename I2)(AND sentinel_for< S1
 function template swap_ranges
 
I1 AND input_iterator< I2 > AND indirectly_swappable< I1, I2 > constexpr 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)(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 indirectly_swappable< I1, I2 > constexpr swap_ranges_result< I1, I2 > RANGES_FUNC() ranges::swap_ranges (I1 begin1, S1 end1, I2 begin2, S2 end2)
 
 ranges::template (typename Rng1, typename I2_)(AND input_iterator< uncvref_t< I2_ > > AND indirectly_swappable< iterator_t< Rng1 >
 
uncvref_t< I2_ > constexpr swap_ranges_result< iterator_t< Rng1 >, uncvref_t< I2_ > > RANGES_FUNC() ranges::swap_ranges (Rng1 &&rng1, I2_ &&begin2)
 
 ranges::template (typename Rng1, typename Rng2)(AND input_range< Rng2 > AND indirectly_swappable< iterator_t< Rng1 >
 
iterator_t< Rng2 > constexpr 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 indirectly_writable< O, indirect_result_t< F &, projected< I, P > > > constexpr unary_transform_result< I, O > RANGES_FUNC() ranges::transform (I first, S last, O out, F fun, P proj=P{})
 
indirect_result_t< F &, projected< iterator_t< Rng >, P > > constexpr 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)(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 indirectly_writable< O, indirect_result_t< F &, projected< I0, P0 >, projected< I1, P1 > > > constexpr 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)(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.
 
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_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)(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)(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{})
 
I constexpr I RANGES_FUNC() ranges::unique (I first, S last, 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)(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].
 
projected< I, P > constexpr I RANGES_FUNC() ranges::unstable_remove_if (I first, I last, C pred, P proj={})
 
projected< iterator_t< Rng >, P > constexpr borrowed_iterator_t< Rng > RANGES_FUNC() ranges::unstable_remove_if (Rng &&rng, C pred, P proj=P{})
 
I AND indirect_strict_weak_order< C, V const *, projected< I, P > > constexpr I RANGES_FUNC() ranges::upper_bound (I first, S last, V const &val, C pred=C{}, P proj=P{})
 
V const projected< iterator_t< Rng >, P > constexpr 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{}
 
V const & ranges::val
 
iter_difference_t< O > ranges::n
 
auto ranges::norig = n
 
auto ranges::b = uncounted(first)
 
 ranges::projected< iterator_t< Rng1 >, P >
 
 ranges::projected< iterator_t< Rng0 >, P0 >
 
 ranges::T
 
 ranges::iter_value_t< I >
 
 ranges::range_value_t< R >
 
 ranges::O
 
 ranges::projected< iterator_t< Rng1 >, P1 >
 
iterator_t< Rng > ranges::middle
 
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::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 
) const &

function template max

function template minmax

function template min

Variable Documentation

◆ middle

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

◆ val

iter_difference_t< O > V const & ranges::val
Initial value:
{
return (*this)(begin(rng), end(rng), val)