Range-v3
Range algorithms, views, and actions for the Standard Library
Classes | Variables
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

◆ 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

◆ 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

◆ 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

◆ 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::with_braced_init_args< ImplFn >::operator()(), ranges::v3::detail::indexed_datum< T[N], Index >::operator=(), ranges::v3::raw_storage_iterator< Val *, Val >::operator=(), and ranges::v3::view_interface< partial_sum_view< Rng, Fun >, Cardinality >::operator[]().

◆ 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

◆ 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