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

Variables

requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 ranges::begin1
 
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > S1 I2 ranges::begin2
 
 ranges::C = equal_to
 
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 ranges::end0
 
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > S1 ranges::end1
 
 ranges::I1
 
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > S1 I2 C P1 P2 ranges::I2
 
 ranges::iterator_t< Rng1 >
 
requires forward_range< Rng1 > &&forward_iterator< uncvref_t< I2Ref > > &&indirectly_comparable< iterator_t< Rng1 >, uncvref_t< I2Ref >, C, P1, P2 > I2Ref C P1 P2 ranges::iterator_t< Rng2 >
 
 ranges::P0 = identity
 
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C P0 P1 ranges::P1 = identity > requires ` input_iterator<I0> && sentinel_for<S0
 
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > S1 I2 C P1 P2 ranges::P2 = identity > requires ` forward_iterator<I1> && sentinel_for<S1
 
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C ranges::pred = C{}
 
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C P0 ranges::proj0 = P0{}
 
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C P0 P1 ranges::proj1
 
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > S1 I2 C P1 P2 ranges::proj2
 
requires input_range< Rng0 > &&input_iterator< uncvref_t< I1Ref > > &&indirectly_comparable< iterator_t< Rng0 >, uncvref_t< I1Ref >, C, P0, P1 > I1Ref C P0 P1 ranges::Rng1
 
requires forward_range< Rng1 > &&forward_iterator< uncvref_t< I2Ref > > &&indirectly_comparable< iterator_t< Rng1 >, uncvref_t< I2Ref >, C, P1, P2 > I2Ref C P1 P2 ranges::Rng2
 
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C P0 P1 ranges::S0
 
requires input_iterator< I0 > &&sentinel_for< S0, I0 > &&input_iterator< I1 > &&indirectly_comparable< I0, I1, C, P0, P1 > S0 I1 C P0 P1 ranges::S1
 
requires forward_iterator< I1 > &&sentinel_for< S1, I1 > &&forward_iterator< I2 > &&indirectly_comparable< I1, I2, C, P1, P2 > S1 I2 C P1 P2 ranges::S2
 
requires input_range< Rng0 > &&input_iterator< uncvref_t< I1Ref > > &&weakly_incrementable< O > &&copy_constructible< F > &&indirectly_writable< O, indirect_result_t< F &, projected< iterator_t< Rng0 >, P0 >, projected< uncvref_t< I1Ref >, P1 > > > ranges::uncvref_t< I1Ref >
 

Function Documentation

◆ adjacent_find()

template<typename I , typename S , typename C = equal_to, typename P = identity>
requires forward_iterator<I>&& sentinel_for<S, I>&& indirect_relation<C, projected<I, P> > I ranges::adjacent_find ( first,
last,
pred = C{},
proj = 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>
requires permutable<I>&& sentinel_for<S, I>&& indirect_relation<Pred, projected<I, Proj> > I ranges::adjacent_remove_if ( first,
last,
Pred  pred = {},
Proj  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.

References ranges::adjacent_remove_if().

◆ binary_search()

template<typename I , typename S , typename V , typename C = less, typename P = identity>
requires forward_iterator<I>&& sentinel_for<S, I>&& indirect_strict_weak_order<C, V const *, projected<I, P> > bool ranges::binary_search ( first,
last,
V const &  val,
pred = C{},
proj = 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>
requires input_iterator<I>&& sentinel_for<S, I>&& constexpr indirect_relation<equal_to, projected<I, P>, V const *> I ranges::find ( first,
last,
V const &  val,
proj = P{} 
)
constexpr

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

template function find

range-based version of the find std algorithm

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

◆ find_if()

template<typename I , typename S , typename F , typename P = identity>
requires input_iterator<I>&& sentinel_for<S, I>&& indirect_unary_predicate<F, projected<I, P> > I ranges::find_if ( first,
last,
pred,
proj = 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>
requires input_iterator<I>&& sentinel_for<S, I>&& indirect_unary_predicate<F, projected<I, P> > I ranges::find_if_not ( first,
last,
pred,
proj = 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>
requires forward_iterator<I>&& sentinel_for<S, I>&& indirect_strict_weak_order<R, projected<I, P> > bool ranges::is_sorted ( first,
last,
rel = R{},
proj = 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>
requires forward_iterator<I>&& sentinel_for<S, I>&& indirect_strict_weak_order<R, projected<I, P> > I ranges::is_sorted_until ( first,
last,
pred = R{},
proj = 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>
requires sortable<I, C, P>&& sentinel_for<S, I> I ranges::unique ( first,
last,
pred = C{},
proj = P{} 
)

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

template function unique

range-based version of the unique std algorithm

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

◆ unique_copy()

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

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

template function unique_copy

range-based version of the unique_copy std algorithm

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

◆ unstable_remove_if()

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

#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

Variable Documentation

◆ proj1

requires forward_range< Rng1 > &&forward_iterator< uncvref_t< I2Ref > > &&indirectly_comparable< iterator_t< Rng1 >, uncvref_t< I2Ref >, C, P1, P2 > I2Ref C P1 ranges::proj1

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

Initial value:
= P1{})
{
for(; begin0 != end0; ++begin0, ++begin1)
if(!invoke(pred, invoke(proj0, *begin0), invoke(proj1, *begin1)))
return false;
return true;
}
template<typename I0
meta::invoke
typename Fn::template invoke< Args... > invoke
Evaluate the invocable Fn with the arguments Args.
Definition: meta.hpp:498