Algorithms

## Description

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

## Classes

struct | ranges::v3::adjacent_find_fn
struct | ranges::v3::all_of_fn
struct | ranges::v3::any_of_fn
struct | ranges::v3::binary_search_fn
struct | ranges::v3::copy_backward_fn
struct | ranges::v3::copy_fn
struct | ranges::v3::copy_if_fn
struct | ranges::v3::copy_n_fn
struct | ranges::v3::count_fn
struct | ranges::v3::count_if_fn
struct | ranges::v3::equal_fn
struct | ranges::v3::equal_range_fn
struct | ranges::v3::fill_fn
struct | ranges::v3::fill_n_fn
struct | ranges::v3::find_end_fn
struct | ranges::v3::find_first_of_fn
struct | ranges::v3::find_fn
struct | ranges::v3::find_if_fn
struct | ranges::v3::find_if_not_fn
struct | ranges::v3::for_each_fn
struct | ranges::v3::for_each_n_fn
struct | ranges::v3::generate_fn
struct | ranges::v3::generate_n_fn
struct | ranges::v3::includes_fn
struct | ranges::v3::inplace_merge_fn
struct | ranges::v3::is_heap_fn
struct | ranges::v3::is_heap_until_fn
struct | ranges::v3::is_partitioned_fn
struct | ranges::v3::is_permutation_fn
struct | ranges::v3::is_sorted_fn
struct | ranges::v3::is_sorted_until_fn
struct | ranges::v3::lexicographical_compare_fn
struct | ranges::v3::lower_bound_fn
struct | ranges::v3::make_heap_fn
struct | ranges::v3::max_element_fn
struct | ranges::v3::max_fn
struct | ranges::v3::merge_fn
struct | ranges::v3::min_element_fn
struct | ranges::v3::min_fn
struct | ranges::v3::minmax_element_fn
struct | ranges::v3::minmax_fn
struct | ranges::v3::mismatch_fn
struct | ranges::v3::move_backward_fn
struct | ranges::v3::move_fn
struct | ranges::v3::next_permutation_fn
struct | ranges::v3::none_of_fn
struct | ranges::v3::nth_element_fn
struct | ranges::v3::partial_sort_copy_fn
struct | ranges::v3::partial_sort_fn
struct | ranges::v3::partition_copy_fn
struct | ranges::v3::partition_fn
struct | ranges::v3::partition_point_fn
struct | ranges::v3::pop_heap_fn
struct | ranges::v3::prev_permutation_fn
struct | ranges::v3::push_heap_fn
struct | ranges::v3::remove_copy_fn
struct | ranges::v3::remove_copy_if_fn
struct | ranges::v3::remove_fn
struct | ranges::v3::remove_if_fn
struct | ranges::v3::replace_copy_fn
struct | ranges::v3::replace_copy_if_fn
struct | ranges::v3::replace_fn
struct | ranges::v3::replace_if_fn
struct | ranges::v3::reverse_copy_fn
struct | ranges::v3::reverse_fn
struct | ranges::v3::rotate_copy_fn
struct | ranges::v3::rotate_fn
class | ranges::v3::sample_fn
struct | ranges::v3::search_fn
struct | ranges::v3::search_n_fn
struct | ranges::v3::set_difference_fn
struct | ranges::v3::set_intersection_fn
struct | ranges::v3::set_symmetric_difference_fn
struct | ranges::v3::set_union_fn
struct | ranges::v3::shuffle_fn
struct | ranges::v3::sort_fn
struct | ranges::v3::sort_heap_fn
struct | ranges::v3::stable_partition_fn
struct | ranges::v3::stable_sort_fn
struct | ranges::v3::swap_ranges_fn
struct | ranges::v3::transform_fn
struct | ranges::v3::unique_copy_fn
struct | ranges::v3::unique_fn
struct | ranges::v3::upper_bound_fn

## Variables

constexpr with_braced_init_args< adjacent_find_fn > | ranges::v3::adjacent_find {}
constexpr with_braced_init_args< all_of_fn > | ranges::v3::all_of {}
constexpr with_braced_init_args< any_of_fn > | ranges::v3::any_of {}
constexpr with_braced_init_args< binary_search_fn > | ranges::v3::binary_search {}
constexpr with_braced_init_args< copy_fn > | ranges::v3::copy {}
constexpr with_braced_init_args< copy_backward_fn > | ranges::v3::copy_backward {}
constexpr with_braced_init_args< copy_if_fn > | ranges::v3::copy_if {}
constexpr with_braced_init_args< copy_n_fn > | ranges::v3::copy_n {}
constexpr with_braced_init_args< with_braced_init_args< count_fn > > | ranges::v3::count {}
constexpr with_braced_init_args< count_if_fn > | ranges::v3::count_if {}
constexpr with_braced_init_args< equal_fn > | ranges::v3::equal {}
constexpr with_braced_init_args< equal_range_fn > | ranges::v3::equal_range {}
constexpr with_braced_init_args< fill_fn > | ranges::v3::fill {}
constexpr fill_n_fn | ranges::v3::fill_n {}
constexpr with_braced_init_args< find_fn > | ranges::v3::find {}
constexpr with_braced_init_args< find_end_fn > | ranges::v3::find_end {}
constexpr with_braced_init_args< find_first_of_fn > | ranges::v3::find_first_of {}
constexpr with_braced_init_args< find_if_fn > | ranges::v3::find_if {}
constexpr with_braced_init_args< find_if_not_fn > | ranges::v3::find_if_not {}
constexpr with_braced_init_args< for_each_fn > | ranges::v3::for_each {}
constexpr with_braced_init_args< for_each_n_fn > | ranges::v3::for_each_n {}
constexpr with_braced_init_args< generate_fn > | ranges::v3::generate {}
constexpr generate_n_fn | ranges::v3::generate_n {}
constexpr with_braced_init_args< includes_fn > | ranges::v3::includes {}
constexpr with_braced_init_args< inplace_merge_fn > | ranges::v3::inplace_merge {}
constexpr with_braced_init_args< is_heap_fn > | ranges::v3::is_heap {}
constexpr with_braced_init_args< is_heap_until_fn > | ranges::v3::is_heap_until {}
constexpr with_braced_init_args< is_partitioned_fn > | ranges::v3::is_partitioned {}
constexpr with_braced_init_args< is_permutation_fn > | ranges::v3::is_permutation {}
constexpr with_braced_init_args< is_sorted_fn > | ranges::v3::is_sorted {}
constexpr with_braced_init_args< is_sorted_until_fn > | ranges::v3::is_sorted_until {}
constexpr with_braced_init_args< lexicographical_compare_fn > | ranges::v3::lexicographical_compare {}
constexpr with_braced_init_args< lower_bound_fn > | ranges::v3::lower_bound {}
constexpr with_braced_init_args< make_heap_fn > | ranges::v3::make_heap {}
constexpr with_braced_init_args< max_fn > | ranges::v3::max {}
constexpr with_braced_init_args< max_element_fn > | ranges::v3::max_element {}
constexpr with_braced_init_args< merge_fn > | ranges::v3::merge {}
constexpr with_braced_init_args< min_fn > | ranges::v3::min {}
constexpr with_braced_init_args< min_element_fn > | ranges::v3::min_element {}
constexpr with_braced_init_args< minmax_fn > | ranges::v3::minmax {}
constexpr with_braced_init_args< minmax_element_fn > | ranges::v3::minmax_element {}
constexpr with_braced_init_args< mismatch_fn > | ranges::v3::mismatch {}
constexpr with_braced_init_args< move_fn > | ranges::v3::move {}
constexpr with_braced_init_args< move_backward_fn > | ranges::v3::move_backward {}
constexpr with_braced_init_args< next_permutation_fn > | ranges::v3::next_permutation {}
constexpr with_braced_init_args< none_of_fn > | ranges::v3::none_of {}
constexpr with_braced_init_args< nth_element_fn > | ranges::v3::nth_element {}
constexpr with_braced_init_args< partial_sort_fn > | ranges::v3::partial_sort {}
constexpr with_braced_init_args< partial_sort_copy_fn > | ranges::v3::partial_sort_copy {}
constexpr with_braced_init_args< partition_fn > | ranges::v3::partition {}
constexpr with_braced_init_args< partition_copy_fn > | ranges::v3::partition_copy {}
constexpr with_braced_init_args< partition_point_fn > | ranges::v3::partition_point {}
constexpr with_braced_init_args< pop_heap_fn > | ranges::v3::pop_heap {}
constexpr with_braced_init_args< prev_permutation_fn > | ranges::v3::prev_permutation {}
constexpr with_braced_init_args< push_heap_fn > | ranges::v3::push_heap {}
constexpr with_braced_init_args< remove_fn > | ranges::v3::remove {}
constexpr with_braced_init_args< remove_copy_fn > | ranges::v3::remove_copy {}
constexpr with_braced_init_args< remove_copy_if_fn > | ranges::v3::remove_copy_if {}
constexpr with_braced_init_args< remove_if_fn > | ranges::v3::remove_if {}
constexpr with_braced_init_args< replace_fn > | ranges::v3::replace {}
constexpr with_braced_init_args< replace_copy_fn > | ranges::v3::replace_copy {}
constexpr with_braced_init_args< replace_copy_if_fn > | ranges::v3::replace_copy_if {}
constexpr with_braced_init_args< replace_if_fn > | ranges::v3::replace_if {}
constexpr with_braced_init_args< reverse_fn > | ranges::v3::reverse {}
constexpr with_braced_init_args< reverse_copy_fn > | ranges::v3::reverse_copy {}
constexpr with_braced_init_args< rotate_fn > | ranges::v3::rotate {}
constexpr with_braced_init_args< rotate_copy_fn > | ranges::v3::rotate_copy {}
constexpr with_braced_init_args< sample_fn > | ranges::v3::sample {}
constexpr with_braced_init_args< search_fn > | ranges::v3::search {}
constexpr with_braced_init_args< search_n_fn > | ranges::v3::search_n {}
constexpr with_braced_init_args< set_difference_fn > | ranges::v3::set_difference {}
constexpr with_braced_init_args< set_intersection_fn > | ranges::v3::set_intersection {}
constexpr with_braced_init_args< set_symmetric_difference_fn > | ranges::v3::set_symmetric_difference {}
constexpr with_braced_init_args< set_union_fn > | ranges::v3::set_union {}
constexpr with_braced_init_args< shuffle_fn > | ranges::v3::shuffle {}
constexpr with_braced_init_args< sort_fn > | ranges::v3::sort {}
constexpr with_braced_init_args< sort_heap_fn > | ranges::v3::sort_heap {}
constexpr with_braced_init_args< stable_partition_fn > | ranges::v3::stable_partition {}
constexpr with_braced_init_args< stable_sort_fn > | ranges::v3::stable_sort {}
constexpr with_braced_init_args< swap_ranges_fn > | ranges::v3::swap_ranges {}
constexpr with_braced_init_args< transform_fn > | ranges::v3::transform {}
constexpr with_braced_init_args< unique_fn > | ranges::v3::unique {}
constexpr with_braced_init_args< unique_copy_fn > | ranges::v3::unique_copy {}
constexpr with_braced_init_args< upper_bound_fn > | ranges::v3::upper_bound {}

## Variable Documentation

## adjacent_find

constexpr with_braced_init_args<adjacent_find_fn> ranges::v3::adjacent_find {}

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

See also
  `adjacent_find_fn`

Referenced by ranges::v3::unique_fn::operator()().

## all_of

constexpr with_braced_init_args<all_of_fn> ranges::v3::all_of {}

`#include <range/v3/algorithm/all_of.hpp>`

See also
  `all_of_fn`

## any_of

constexpr with_braced_init_args<any_of_fn> ranges::v3::any_of {}

`#include <range/v3/algorithm/any_of.hpp>`

See also
  `any_of_fn`

## binary_search

constexpr with_braced_init_args<binary_search_fn> ranges::v3::binary_search {}

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

See also
  `binary_search_fn`

## copy

constexpr with_braced_init_args<copy_fn> ranges::v3::copy {}

`#include <range/v3/algorithm/copy.hpp>`

See also
  `copy_fn`

Referenced by ranges::v3::detail::indexed_datum< T[N], Index >::operator=().

## copy_backward

constexpr with_braced_init_args<copy_backward_fn> ranges::v3::copy_backward {}

`#include <range/v3/algorithm/copy_backward.hpp>`

See also
  `copy_backward_fn`

## copy_if

constexpr with_braced_init_args<copy_if_fn> ranges::v3::copy_if {}

`#include <range/v3/algorithm/copy_if.hpp>`

See also
  `copy_if_fn`

## copy_n

constexpr with_braced_init_args<copy_n_fn> ranges::v3::copy_n {}

`#include <range/v3/algorithm/copy_n.hpp>`

See also
  `copy_n_fn`

## count

constexpr with_braced_init_args<with_braced_init_args<count_fn> > ranges::v3::count {}

`#include <range/v3/algorithm/count.hpp>`

See also
  `count_fn`

## count_if

constexpr with_braced_init_args<count_if_fn> ranges::v3::count_if {}

`#include <range/v3/algorithm/count_if.hpp>`

See also
  `count_if_fn`

## equal

constexpr with_braced_init_args<equal_fn> ranges::v3::equal {}

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

See also
  `equal_fn`

Referenced by ranges::v3::join_view< Rng, void >::size(), and ranges::v3::join_view< Rng, ValRng >::size().

## equal_range

constexpr with_braced_init_args<equal_range_fn> ranges::v3::equal_range {}

`#include <range/v3/algorithm/equal_range.hpp>`

See also
  `equal_range_fn`

## fill

constexpr with_braced_init_args<fill_fn> ranges::v3::fill {}

`#include <range/v3/algorithm/fill.hpp>`

See also
  `fill_fn`

## fill_n

constexpr fill_n_fn ranges::v3::fill_n {}

`#include <range/v3/algorithm/fill_n.hpp>`

See also
  `fill_n_fn`

## find

constexpr with_braced_init_args<find_fn> ranges::v3::find {}

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

See also
  `find_fn`

## find_end

constexpr with_braced_init_args<find_end_fn> ranges::v3::find_end {}

`#include <range/v3/algorithm/find_end.hpp>`

See also
  `find_end_fn`

## find_first_of

constexpr with_braced_init_args<find_first_of_fn> ranges::v3::find_first_of {}

`#include <range/v3/algorithm/find_first_of.hpp>`

See also
  `find_first_of_fn`

## find_if

constexpr with_braced_init_args<find_if_fn> ranges::v3::find_if {}

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

See also
  `find_if_fn`

## find_if_not

constexpr with_braced_init_args<find_if_not_fn> ranges::v3::find_if_not {}

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

See also
  `find_if_not_fn`

## for_each

constexpr with_braced_init_args<for_each_fn> ranges::v3::for_each {}

related

`#include <range/v3/algorithm/for_each.hpp>`

See also
  `for_each_fn`

## for_each_n

constexpr with_braced_init_args<for_each_n_fn> ranges::v3::for_each_n {}

`#include <range/v3/algorithm/for_each_n.hpp>`

See also
  `for_each_n_fn`

## generate

constexpr with_braced_init_args<generate_fn> ranges::v3::generate {}

related

`#include <range/v3/algorithm/generate.hpp>`

See also
  `generate_fn`

## generate_n

constexpr generate_n_fn ranges::v3::generate_n {}

related

`#include <range/v3/algorithm/generate_n.hpp>`

See also
  `generate_n_fn`

## includes

constexpr with_braced_init_args<includes_fn> ranges::v3::includes {}

`#include <range/v3/algorithm/set_algorithm.hpp>`

See also
  `includes_fn`

## inplace_merge

constexpr with_braced_init_args<inplace_merge_fn> ranges::v3::inplace_merge {}

`#include <range/v3/algorithm/inplace_merge.hpp>`

See also
  `inplace_merge_fn`

## is_heap

constexpr with_braced_init_args<is_heap_fn> ranges::v3::is_heap {}

`#include <range/v3/algorithm/heap_algorithm.hpp>`

See also
  `is_heap_fn`

## is_heap_until

constexpr with_braced_init_args<is_heap_until_fn> ranges::v3::is_heap_until {}

`#include <range/v3/algorithm/heap_algorithm.hpp>`

See also
  `is_heap_until_fn`

## is_partitioned

constexpr with_braced_init_args<is_partitioned_fn> ranges::v3::is_partitioned {}

`#include <range/v3/algorithm/is_partitioned.hpp>`

See also
  `is_partitioned_fn`

## is_permutation

constexpr with_braced_init_args<is_permutation_fn> ranges::v3::is_permutation {}

`#include <range/v3/algorithm/permutation.hpp>`

See also
  `is_permutation_fn`

## is_sorted

constexpr with_braced_init_args<is_sorted_fn> ranges::v3::is_sorted {}

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

See also
  `is_sorted_fn`

## is_sorted_until

constexpr with_braced_init_args<is_sorted_until_fn> ranges::v3::is_sorted_until {}

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

See also
  `is_sorted_until_fn`

Referenced by ranges::v3::is_sorted_fn::operator()().

## lexicographical_compare

constexpr with_braced_init_args<lexicographical_compare_fn> ranges::v3::lexicographical_compare {}

`#include <range/v3/algorithm/lexicographical_compare.hpp>`

See also
  `lexicographical_compare_fn`

## lower_bound

constexpr with_braced_init_args<lower_bound_fn> ranges::v3::lower_bound {}

`#include <range/v3/algorithm/lower_bound.hpp>`

See also
  `lower_bound_fn`

Referenced by ranges::v3::binary_search_fn::operator()().

## make_heap

constexpr with_braced_init_args<make_heap_fn> ranges::v3::make_heap {}

`#include <range/v3/algorithm/heap_algorithm.hpp>`

See also
  `make_heap_fn`

## max

constexpr with_braced_init_args<max_fn> ranges::v3::max {}

`#include <range/v3/algorithm/max.hpp>`

See also
  `max_fn`

## max_element

constexpr with_braced_init_args<max_element_fn> ranges::v3::max_element {}

`#include <range/v3/algorithm/max_element.hpp>`

See also
  `max_element_fn`

## merge

constexpr with_braced_init_args<merge_fn> ranges::v3::merge {}

`#include <range/v3/algorithm/merge.hpp>`

See also
  `merge_fn`

## min

constexpr with_braced_init_args<min_fn> ranges::v3::min {}

`#include <range/v3/algorithm/min.hpp>`

See also
  `min_fn`

## min_element

constexpr with_braced_init_args<min_element_fn> ranges::v3::min_element {}

`#include <range/v3/algorithm/min_element.hpp>`

See also
  `min_element_fn`

## minmax

constexpr with_braced_init_args<minmax_fn> ranges::v3::minmax {}

`#include <range/v3/algorithm/minmax.hpp>`

See also
  `minmax_fn`

## minmax_element

constexpr with_braced_init_args<minmax_element_fn> ranges::v3::minmax_element {}

`#include <range/v3/algorithm/minmax_element.hpp>`

See also
  `minmax_element_fn`

## mismatch

constexpr with_braced_init_args<mismatch_fn> ranges::v3::mismatch {}

`#include <range/v3/algorithm/mismatch.hpp>`

See also
  `mismatch_fn`

## move

constexpr with_braced_init_args<move_fn> ranges::v3::move {}

related

`#include <range/v3/algorithm/move.hpp>`

See also
  `move_fn`

Referenced by ranges::v3::cartesian_product_view< Views >::cartesian_product_view(), ranges::v3::mutable_< T >::mutable_(), ranges::v3::is_sorted_fn::operator()(), ranges::v3::binary_search_fn::operator()(), ranges::v3::unique_fn::operator()(), ranges::v3::upper_bound_fn::operator()(), ranges::v3::adjacent_find_fn::operator()(), ranges::v3::find_fn::operator()(), ranges::v3::find_if_fn::operator()(), ranges::v3::find_if_not_fn::operator()(), ranges::v3::unique_copy_fn::operator()(), ranges::v3::with_braced_init_args< ImplFn >::operator()(), ranges::v3::detail::indexed_datum< T[N], Index >::operator=(), ranges::v3::raw_storage_iterator< Val *, Val >::operator=(), ranges::v3::view_interface< partial_sum_view< Rng, Fun >, Cardinality >::operator[](), ranges::v3::join_view< Rng, void >::size(), ranges::v3::iter_transform_view< Rng, indirected< Fun > >::size(), ranges::v3::join_view< Rng, ValRng >::size(), and ranges::v3::iter_zip_with_view< detail::indirect_zip_fn_, Rngs... >::size().

## move_backward

constexpr with_braced_init_args<move_backward_fn> ranges::v3::move_backward {}

`#include <range/v3/algorithm/move_backward.hpp>`

See also
  `move_backward_fn`

## next_permutation

constexpr with_braced_init_args<next_permutation_fn> ranges::v3::next_permutation {}

`#include <range/v3/algorithm/permutation.hpp>`

See also
  `next_permutation_fn`

## none_of

constexpr with_braced_init_args<none_of_fn> ranges::v3::none_of {}

`#include <range/v3/algorithm/none_of.hpp>`

See also
  `none_of_fn`

## nth_element

constexpr with_braced_init_args<nth_element_fn> ranges::v3::nth_element {}

`#include <range/v3/algorithm/nth_element.hpp>`

See also
  `nth_element_fn`

## partial_sort

constexpr with_braced_init_args<partial_sort_fn> ranges::v3::partial_sort {}

`#include <range/v3/algorithm/partial_sort.hpp>`

See also
  `partial_sort_fn`

## partial_sort_copy

constexpr with_braced_init_args<partial_sort_copy_fn> ranges::v3::partial_sort_copy {}

`#include <range/v3/algorithm/partial_sort_copy.hpp>`

See also
  `partial_sort_copy_fn`

## partition

constexpr with_braced_init_args<partition_fn> ranges::v3::partition {}

`#include <range/v3/algorithm/partition.hpp>`

See also
  `partition_fn`

## partition_copy

constexpr with_braced_init_args<partition_copy_fn> ranges::v3::partition_copy {}

`#include <range/v3/algorithm/partition_copy.hpp>`

See also
  `partition_copy_fn`

## partition_point

constexpr with_braced_init_args<partition_point_fn> ranges::v3::partition_point {}

`#include <range/v3/algorithm/partition_point.hpp>`

See also
  `partition_point_fn`

Referenced by ranges::v3::upper_bound_fn::operator()().

## pop_heap

constexpr with_braced_init_args<pop_heap_fn> ranges::v3::pop_heap {}

`#include <range/v3/algorithm/heap_algorithm.hpp>`

See also
  `pop_heap_fn`

## prev_permutation

constexpr with_braced_init_args<prev_permutation_fn> ranges::v3::prev_permutation {}

`#include <range/v3/algorithm/permutation.hpp>`

See also
  `prev_permutation_fn`

## push_heap

constexpr with_braced_init_args<push_heap_fn> ranges::v3::push_heap {}

`#include <range/v3/algorithm/heap_algorithm.hpp>`

See also
  `push_heap_fn`

## remove

constexpr with_braced_init_args<remove_fn> ranges::v3::remove {}

`#include <range/v3/algorithm/remove.hpp>`

See also
  `remove_fn`

## remove_copy

constexpr with_braced_init_args<remove_copy_fn> ranges::v3::remove_copy {}

`#include <range/v3/algorithm/remove_copy.hpp>`

See also
  `remove_copy_fn`

## remove_copy_if

constexpr with_braced_init_args<remove_copy_if_fn> ranges::v3::remove_copy_if {}

`#include <range/v3/algorithm/remove_copy_if.hpp>`

See also
  `remove_copy_if_fn`

## remove_if

constexpr with_braced_init_args<remove_if_fn> ranges::v3::remove_if {}

related

`#include <range/v3/algorithm/remove_if.hpp>`

See also
  `remove_if_fn`

## replace

constexpr with_braced_init_args<replace_fn> ranges::v3::replace {}

related

`#include <range/v3/algorithm/replace.hpp>`

See also
  `replace_fn`

## replace_copy

constexpr with_braced_init_args<replace_copy_fn> ranges::v3::replace_copy {}

`#include <range/v3/algorithm/replace_copy.hpp>`

See also
  `replace_copy_fn`

## replace_copy_if

constexpr with_braced_init_args<replace_copy_if_fn> ranges::v3::replace_copy_if {}

`#include <range/v3/algorithm/replace_copy_if.hpp>`

See also
  `replace_copy_if_fn`

## replace_if

constexpr with_braced_init_args<replace_if_fn> ranges::v3::replace_if {}

related

`#include <range/v3/algorithm/replace_if.hpp>`

See also
  `replace_if_fn`

## reverse

constexpr with_braced_init_args<reverse_fn> ranges::v3::reverse {}

related

`#include <range/v3/algorithm/reverse.hpp>`

See also
  `reverse_fn`

## reverse_copy

constexpr with_braced_init_args<reverse_copy_fn> ranges::v3::reverse_copy {}

`#include <range/v3/algorithm/reverse_copy.hpp>`

See also
  `reverse_copy_fn`

## rotate

constexpr with_braced_init_args<rotate_fn> ranges::v3::rotate {}

`#include <range/v3/algorithm/rotate.hpp>`

See also
  `rotate_fn`

## rotate_copy

constexpr with_braced_init_args<rotate_copy_fn> ranges::v3::rotate_copy {}

`#include <range/v3/algorithm/rotate_copy.hpp>`

See also
  `rotate_copy_fn`

## sample

constexpr with_braced_init_args<sample_fn> ranges::v3::sample {}

related

`#include <range/v3/algorithm/sample.hpp>`

See also
  `sample_fn`

## search

constexpr with_braced_init_args<search_fn> ranges::v3::search {}

`#include <range/v3/algorithm/search.hpp>`

See also
  `search_fn`

## search_n

constexpr with_braced_init_args<search_n_fn> ranges::v3::search_n {}

`#include <range/v3/algorithm/search_n.hpp>`

See also
  `search_n_fn`

## set_difference

constexpr with_braced_init_args<set_difference_fn> ranges::v3::set_difference {}

related

`#include <range/v3/algorithm/set_algorithm.hpp>`

See also
  `set_difference_fn`

## set_intersection

constexpr with_braced_init_args<set_intersection_fn> ranges::v3::set_intersection {}

related

`#include <range/v3/algorithm/set_algorithm.hpp>`

See also
  `set_intersection_fn`

## set_symmetric_difference

constexpr with_braced_init_args<set_symmetric_difference_fn> ranges::v3::set_symmetric_difference {}

related

`#include <range/v3/algorithm/set_algorithm.hpp>`

See also
  `set_symmetric_difference_fn`

## set_union

constexpr with_braced_init_args<set_union_fn> ranges::v3::set_union {}

related

`#include <range/v3/algorithm/set_algorithm.hpp>`

See also
  `set_union_fn`

## shuffle

constexpr with_braced_init_args<shuffle_fn> ranges::v3::shuffle {}

related

`#include <range/v3/algorithm/shuffle.hpp>`

See also
  `shuffle_fn`

## sort

constexpr with_braced_init_args<sort_fn> ranges::v3::sort {}

related

`#include <range/v3/algorithm/sort.hpp>`

See also
  `sort_fn`

## sort_heap

constexpr with_braced_init_args<sort_heap_fn> ranges::v3::sort_heap {}

`#include <range/v3/algorithm/heap_algorithm.hpp>`

See also
  `sort_heap_fn`

## stable_partition

constexpr with_braced_init_args<stable_partition_fn> ranges::v3::stable_partition {}

`#include <range/v3/algorithm/stable_partition.hpp>`

See also
  `stable_partition_fn`

## stable_sort

constexpr with_braced_init_args<stable_sort_fn> ranges::v3::stable_sort {}

related

`#include <range/v3/algorithm/stable_sort.hpp>`

See also
  `stable_sort_fn`

## swap_ranges

constexpr with_braced_init_args<swap_ranges_fn> ranges::v3::swap_ranges {}

`#include <range/v3/algorithm/swap_ranges.hpp>`

See also
  `swap_ranges_fn`

## transform

constexpr with_braced_init_args<transform_fn> ranges::v3::transform {}

related

`#include <range/v3/algorithm/transform.hpp>`

See also
  `transform_fn`

## unique

constexpr with_braced_init_args<unique_fn> ranges::v3::unique {}

related

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

See also
  `unique_fn`

## unique_copy

constexpr with_braced_init_args<unique_copy_fn> ranges::v3::unique_copy {}

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

See also
  `unique_copy_fn`

## upper_bound

constexpr with_braced_init_args<upper_bound_fn> ranges::v3::upper_bound {}

`#include <range/v3/algorithm/upper_bound.hpp>`

See also
  `upper_bound_fn`