Range-v3
Range algorithms, views, and actions for the Standard Library
Algorithms

Description

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

Typedefs

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

Functions

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

Function Documentation

◆ adjacent_find()

template<typename I , typename S , typename C = equal_to, typename P = identity>
auto ranges::adjacent_find ( first,
last,
pred = C{},
proj = P{} 
) -> I requires forward_iterator<I> && sentinel_for<S, I> && indirect_relation<C, projected<I, P>>

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

function template adjacent_find

range-based version of the adjacent_find std algorithm

Precondition
Rng is a model of the Range concept
C is a model of the BinaryPredicate concept

◆ adjacent_remove_if()

template<typename I , typename S , typename Pred , typename Proj = identity>
auto ranges::adjacent_remove_if ( first,
last,
Pred  pred = {},
Proj  proj = {} 
) -> I requires permutable<I> && sentinel_for<S, I> && indirect_relation<Pred, projected<I, Proj>>

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

function adjacent_remove_if

range-based version of the adjacent_remove_if algorithm

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

◆ binary_search()

template<typename I , typename S , typename V , typename C = less, typename P = identity>
auto ranges::binary_search ( first,
last,
V const &  val,
pred = C{},
proj = P{} 
) -> bool requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<C, V const *, projected<I, P>>

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

function template binary_search

range-based version of the binary_search std algorithm

Precondition
Rng is a model of the Range concept

◆ find()

template<typename I , typename S , typename V , typename P = identity>
auto ranges::find ( first,
last,
V const &  val,
proj = P{} 
) -> I requires input_iterator<I> && sentinel_for<S, I> && indirect_relation<equal_to, projected<I, P>, V const *>

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

template function find

range-based version of the find std algorithm

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

◆ find_if()

template<typename I , typename S , typename F , typename P = identity>
auto ranges::find_if ( first,
last,
pred,
proj = P{} 
) -> I requires input_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<F, projected<I, P>>

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

template function find

range-based version of the find std algorithm

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

◆ find_if_not()

template<typename I , typename S , typename F , typename P = identity>
auto ranges::find_if_not ( first,
last,
pred,
proj = P{} 
) -> I requires input_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<F, projected<I, P>>

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

template function find_if_not

range-based version of the find_if_not std algorithm

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

◆ is_sorted()

template<typename I , typename S , typename R = less, typename P = identity>
auto ranges::is_sorted ( first,
last,
rel = R{},
proj = P{} 
) -> bool requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<R, projected<I, P>>

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

template function is_sorted

range-based version of the is_sorted std algorithm

Works on forward_ranges

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

◆ is_sorted_until()

template<typename I , typename S , typename R = less, typename P = identity>
auto ranges::is_sorted_until ( first,
last,
pred = R{},
proj = P{} 
) -> I requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<R, projected<I, P>>

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

template function is_sorted_until

range-based version of the is_sorted_until std algorithm

Works on forward_ranges

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

◆ unique()

template<typename I , typename S , typename C = equal_to, typename P = identity>
auto ranges::unique ( first,
last,
pred = C{},
proj = P{} 
) -> I requires sortable<I, C, P> && sentinel_for<S, I>

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

template function unique

range-based version of the unique std algorithm

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

◆ unique_copy()

template<typename I , typename S , typename O , typename C = equal_to, typename P = identity>
auto ranges::unique_copy ( first,
last,
out,
pred = C{},
proj = P{} 
) -> unique_copy_result<I, O> requires input_iterator<I> && sentinel_for<S, I> && indirect_relation<C, projected<I, P>> && weakly_incrementable<O> && indirectly_copyable<I, O> && (forward_iterator<I> || forward_iterator<O> || indirectly_copyable_storable<I, O>)

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

template function unique_copy

range-based version of the unique_copy std algorithm

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

◆ unstable_remove_if()

template<typename I , typename C , typename P = identity>
auto ranges::unstable_remove_if ( first,
last,
pred,
proj = {} 
) -> I requires bidirectional_iterator<I> && permutable<I> && indirect_unary_predicate<C, projected<I, P>>

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

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

function template unstable_remove_if