Algorithms

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

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

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

Detailed Description

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

Function Documentation

adjacent_find()

template<typename I , typename S , typename C = equal_to, typename P = identity>
requires forward_iterator<I> && sentinel_for<S, I> && indirect_relation<C, projected<I, P>>

constexpr I ranges::adjacent_find ( I  first, S  last, C  pred = C{}, P  proj = P{}  )

constexpr

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

function template adjacent_find

range-based version of the adjacent_find std algorithm

Precondition

Rng is a model of the range concept

C is a model of the BinaryPredicate concept

adjacent_remove_if()

template<typename I , typename S , typename Pred , typename Proj = identity>
requires permutable<I> && sentinel_for<S, I> && indirect_relation<Pred, projected<I, Proj>>

constexpr I ranges::adjacent_remove_if ( I  first, S  last, Pred  pred = {}, Proj  proj = {}  )

constexpr

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

function adjacent_remove_if

range-based version of the adjacent_remove_if algorithm

Precondition

Rng is a model of the forward_range concept.

Pred is a model of the BinaryPredicate concept.

binary_search()

template<typename I , typename S , typename V , typename C = less, typename P = identity>
requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<C, V const *, projected<I, P>>

constexpr bool ranges::binary_search ( I  first, S  last, V const &  val, C  pred = C{}, P  proj = P{}  )

constexpr

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

function template binary_search

range-based version of the binary_search std algorithm

Precondition

Rng is a model of the range concept

find()

template<typename I , typename S , typename V , typename P = identity>
requires input_iterator<I> && sentinel_for<S, I> && indirect_relation<equal_to, projected<I, P>, V const *>

constexpr I ranges::find ( I  first, S  last, V const &  val, P  proj = P{}  )

constexpr

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

template function find

range-based version of the find std algorithm

Precondition

Rng is a model of the range concept

I is a model of the input_iterator concept

S is a model of the sentinel_for<I> concept

P is a model of the invocable<iter_common_reference_t<I>> concept

The ResultType of P is equality_comparable with V

find_if()

template<typename I , typename S , typename F , typename P = identity>
requires input_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<F, projected<I, P>>

constexpr I ranges::find_if ( I  first, S  last, F  pred, P  proj = P{}  )

constexpr

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

template function find

range-based version of the find std algorithm

Precondition

Rng is a model of the range concept

I is a model of the input_iterator concept

S is a model of the sentinel_for<I> concept

P is a model of the invocable<V> concept, where V is the value type of I.

F models predicate<X>, where X is the result type of invocable<P, V>

find_if_not()

template<typename I , typename S , typename F , typename P = identity>
requires input_iterator<I> && sentinel_for<S, I> && indirect_unary_predicate<F, projected<I, P>>

constexpr I ranges::find_if_not ( I  first, S  last, F  pred, P  proj = P{}  )

constexpr

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

template function find_if_not

range-based version of the find_if_not std algorithm

Precondition

Rng is a model of the range concept

I is a model of the input_iterator concept

S is a model of the sentinel_for<I> concept

P is a model of the invocable<V> concept, where V is the value type of I.

F models predicate<X>, where X is the result type of invocable<P, V>

is_sorted()

template<typename I , typename S , typename R = less, typename P = identity>
requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<R, projected<I, P>>

constexpr bool ranges::is_sorted ( I  first, S  last, R  rel = R{}, P  proj = P{}  )

constexpr

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

template function is_sorted

range-based version of the is_sorted std algorithm

Works on forward_ranges

Precondition

Rng is a model of the forward_range concept

I is a model of the forward_iterator concept

S and I model the sentinel_for<S, I> concept

R and projected<I, P> model the indirect_strict_weak_order<R, projected<I, P>> concept

is_sorted_until()

template<typename I , typename S , typename R = less, typename P = identity>
requires forward_iterator<I> && sentinel_for<S, I> && indirect_strict_weak_order<R, projected<I, P>>

constexpr I ranges::is_sorted_until ( I  first, S  last, R  pred = R{}, P  proj = P{}  )

constexpr

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

template function is_sorted_until

range-based version of the is_sorted_until std algorithm

Works on forward_ranges

Precondition

Rng is a model of the forward_range concept

I is a model of the forward_iterator concept

S and I model the sentinel_for<S, I> concept

R and projected<I, P> model the indirect_strict_weak_order<R, projected<I, P>> concept

unique()

template<typename I , typename S , typename C = equal_to, typename P = identity>
requires sortable<I, C, P> && sentinel_for<S, I>

constexpr I ranges::unique ( I  first, S  last, C  pred = C{}, P  proj = P{}  )

constexpr

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

template function unique

range-based version of the unique std algorithm

Precondition

Rng is a model of the forward_range concept

I is a model of the forward_iterator concept

S is a model of the sentinel_for concept

C is a model of the relation concept

unique_copy()

template<typename I , typename S , typename O , typename C = equal_to, typename P = identity>
requires input_iterator<I> && sentinel_for<S, I> && indirect_relation<C, projected<I, P>> && weakly_incrementable<O> && indirectly_copyable<I, O> && (forward_iterator<I> || forward_iterator<O> || indirectly_copyable_storable<I, O>)

constexpr unique_copy_result< I, O > ranges::unique_copy ( I  first, S  last, O  out, C  pred = C{}, P  proj = P{}  )

constexpr

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

template function unique_copy

range-based version of the unique_copy std algorithm

Precondition

Rng is a model of the input_range concept

O is a model of the weakly_incrementable concept

C is a model of the relation concept

unstable_remove_if()

template<typename I , typename C , typename P = identity>
requires bidirectional_iterator<I> && permutable<I> && indirect_unary_predicate<C, projected<I, P>>

constexpr I ranges::unstable_remove_if ( I  first, I  last, C  pred, P  proj = {}  )

constexpr

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

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

function template unstable_remove_if