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

Classes
This is an index of all the classes in the library with links to the corresponding documentation.
[detail level 1 2 3 4]

▼N concepts | INTERNAL ONLY
▼N detail |
C ignore |
C Nil |
C tag |
C basic_common_reference | Users can specialize this to hook the `common_reference_with` concept
C common_reference | Users can specialize this to hook the `common_reference_with` concept
C common_reference< T > |
C common_reference< T, U > |
C common_reference< T, U, Vs... > |
C common_type | Users should specialize this to hook the `common_with` concept until `std` gets a SFINAE-friendly `std::common_type` and there's some sane way to deal with cv and ref qualifiers
C common_type< T > |
C common_type< T, U > |
C common_type< T, U, Vs... > |
C is_nothrow_swappable |
C is_nothrow_swappable_with |
C is_swappable |
C is_swappable_with |
C return_t_ |
▼N meta | Tiny metaprogramming library
▼N detail |
C count_ |
C count_< list< Ts... >, T > |
C count_if_ |
C require_constant |
▼N extension | Extend meta with your own datatypes
C apply | A trait that unpacks the types in the type list `L` into the invocable `Fn`
C apply< Fn, integer_sequence< T, Is... > > |
C apply< Fn, Ret(Args...)> |
C apply< Fn, T< Ts... > > |
C bind_back | An invocable that partially applies the invocable `Fn` by binding the arguments `Us` to the back of `Fn`
C bind_front | An invocable that partially applies the invocable `Fn` by binding the arguments `Ts` to the front of `Fn`
C compose_ | Compose the Invocables `Fns` in the parameter pack `Ts`
C compose_< Fn0 > |
C compose_< Fn0, Fns... > |
C defer | A wrapper that defers the instantiation of a template `C` with type parameters `Ts` in a `lambda` or `let` expression
C defer_i | A wrapper that defers the instantiation of a template `C` with integral constant parameters `Is` in a `lambda` or `let` expression
C flip | An invocable that reverses the order of the first two arguments
C id | A trait that always returns its argument `T`. It is also an invocable that always returns `T`
C list | A list of types
C nil_ | An empty type
C quote | Turn a template `C` into an invocable
C quote_i | Turn a template `C` taking literals of type `T` into a invocable
C var | For use when defining local variables in `meta::let` expressions
▼N ranges |
▼N actions |
C action_closure |
C action_closure_base |
C adjacent_remove_if_fn |
C drop_fn |
C drop_while_fn |
C join_fn |
C remove_fn |
C remove_if_fn |
C reverse_fn | Reversed the source range in-place
C shuffle_fn |
C slice_fn |
C sort_fn |
C split_fn |
C split_when_fn |
C stable_sort_fn |
C stride_fn |
C take_fn |
C take_while_fn |
C transform_fn |
C unique_fn |
C unstable_remove_if_fn |
▼N aux |
C copy_fn |
C move_fn |
▼N detail |
C bind_back_fn_ |
▼N experimental |
▼N views |
C shared_fn |
C coroutine_owner |
C enable_coroutine_owner |
C generator |
C shared_closure |
C shared_closure_base |
C shared_view |
C sized_generator |
▼N views |
C addressof_fn |
C adjacent_filter_base_fn |
C adjacent_filter_fn |
C adjacent_remove_if_base_fn |
C adjacent_remove_if_fn |
C all_fn |
C c_str_fn | View a `\0`-terminated C string (e.g. from a const char*) as a range
C cache1_fn |
C cartesian_product_fn |
C chunk_base_fn |
C chunk_fn |
C closed_indices_fn | Inclusive range of indices: [from, to]
C closed_iota_fn |
C common_fn |
C concat_fn |
C const_fn |
C counted_fn |
C cpp20_common_fn |
C cpp20_counted_fn |
C cpp20_filter_base_fn | Given a source range and a unary predicate, present a view of the elements that satisfy the predicate
C cpp20_filter_fn |
C cpp20_join_fn |
C cycle_fn | Returns an infinite range that endlessly repeats the source range
C delimit_base_fn |
C delimit_fn |
C drop_base_fn |
C drop_exactly_base_fn |
C drop_exactly_fn |
C drop_fn |
C drop_last_base_fn |
C drop_last_fn |
C drop_while_base_fn |
C drop_while_bind_fn |
C drop_while_fn |
C enumerate_fn | Lazily pairs each element in a source range with its corresponding index
C exclusive_scan_base_fn |
C exclusive_scan_fn |
C filter_base_fn | Given a source range, unary predicate, and optional projection, present a view of the elements that satisfy the predicate
C filter_fn |
C for_each_base_fn | Lazily applies an unary function to each element in the source range that returns another range (possibly empty), flattening the result
C for_each_fn |
C generate_fn |
C generate_n_fn |
C group_by_base_fn |
C group_by_fn |
C indices_fn | Half-open range of indices: [from, to)
C indirect_fn |
C intersperse_base_fn |
C intersperse_fn |
C ints_fn |
C iota_fn |
C iter_take_while_base_fn |
C iter_take_while_fn |
C iter_transform_base_fn |
C iter_transform_fn |
C iter_zip_with_fn |
C join_base_fn |
C join_bind_fn |
C join_fn |
C keys_fn |
C linear_distribute_fn | Distributes `n` values linearly in the closed interval [`from`, `to`]
C linear_distribute_view |
C move_fn |
C partial_sum_base_fn |
C partial_sum_fn |
C ref_fn |
C remove_base_fn |
C remove_bind_fn |
C remove_fn |
C remove_if_base_fn | Given a source range, unary predicate, and optional projection, present a view of the elements that do not satisfy the predicate
C remove_if_bind_fn |
C remove_if_fn |
C repeat_fn |
C repeat_n_fn |
C replace_base_fn |
C replace_fn |
C replace_if_base_fn |
C replace_if_fn |
C reverse_fn |
C sample_base_fn | Returns a random sample of a range of length `size(range)`
C sample_fn |
C set_difference_base_fn |
C set_difference_fn |
C set_intersection_base_fn |
C set_intersection_fn |
C set_symmetric_difference_base_fn |
C set_symmetric_difference_fn |
C set_union_base_fn |
C set_union_fn |
C single_fn |
C slice_base_fn |
C slice_fn |
C sliding_base_fn |
C sliding_fn |
C split_base_fn |
C split_fn |
C split_when_base_fn |
C split_when_fn |
C stride_base_fn |
C stride_fn |
C tail_fn |
C take_base_fn |
C take_exactly_base_fn |
C take_exactly_fn |
C take_fn |
C take_last_base_fn |
C take_last_fn |
C take_while_base_fn |
C take_while_bind_fn |
C take_while_fn |
C tokenize_base_fn |
C tokenize_fn |
C transform_base_fn |
C transform_fn |
C trim_base_fn |
C trim_bind_fn |
C trim_fn |
C unbounded_fn |
C unique_base_fn |
C unique_fn |
C values_fn |
C view_closure |
C view_closure_base |
C zip_fn |
C zip_with_fn |
C accumulate_fn |
C adaptor_base |
C adaptor_cursor |
C adaptor_sentinel |
C adjacent_difference_fn |
C adjacent_filter_view |
C adjacent_remove_if_view |
C advance_fn |
C any |
C any_view | A type-erased view
C any_view< Ref, Cat, meta::if_c<(Cat &category::forward)==category::input > > |
C at_fn | Checked indexed range access
C back_fn |
C back_insert_iterator |
C back_inserter_fn |
C bad_any_cast |
C bad_optional_access |
C base_adaptor_sentinel |
C basic_iterator |
C basic_mixin |
C basic_view |
C begin_tag |
C bidirectional_range_tag |
C bind_back_fn |
C bind_element |
C bind_element< reference_wrapper< T > > |
C bind_element< std::reference_wrapper< T > > |
C bitwise_or |
C box |
C box< Element, Tag, detail::box_compress::coalesce > |
C box< Element, Tag, detail::box_compress::ebo > |
C cache1_view |
C cartesian_product_view |
C chunk_view |
C chunk_view_ |
C chunk_view_< Rng, false > |
C closed_iota_view | An iota view in a closed range
C coerce |
C coerce< T & > |
C coerce< T && > |
C coerce< T const > |
C common_comparison_category |
C common_iterator |
C common_pair |
C common_range_tag |
C common_tuple |
C common_view |
C common_view< Rng, true > |
C compare_three_way |
C compose_fn |
C composed |
C compressed_pair |
C concat_view |
C const_view |
C contiguous_iterator_tag |
C contiguous_range_tag |
C convert_to |
C copy_tag |
C counted_view |
C cycled_view |
C cycled_view< Rng, true > |
C dangling |
C default_sentinel_t |
C delimit_view |
C distance_compare_fn |
C distance_fn |
C drop_exactly_view |
C drop_last_view |
C drop_last_view< Rng, detail::drop_last_view::mode_bidi > |
C drop_last_view< Rng, detail::drop_last_view::mode_forward > |
C drop_last_view< Rng, detail::drop_last_view::mode_sized > |
C drop_view |
C drop_while_view |
C empty_view |
C end_tag |
C enumerate_fn |
C equal_to |
C exclusive_scan_view |
C filter_view |
C forward_range_tag |
C front_fn |
C front_insert_iterator |
C front_inserter_fn |
C generate_n_view |
C generate_view |
C get_cursor_fn | Get a cursor from a basic_iterator
C getlines_fn |
C getlines_view |
C greater |
C greater_equal |
C group_by_view |
C identity |
C identity_adaptor |
C in_place_t |
C incrementable_traits |
C incrementable_traits< detail::projected_< I, Proj > > |
C incrementable_traits< T const > |
C index_fn | Unchecked indexed range access
C indirect_fn |
C indirect_view |
C indirected |
C indirectly_readable_traits |
C indirectly_readable_traits< common_iterator< I, S > > |
C indirectly_readable_traits< iterator_wrapper< I > > |
C indirectly_readable_traits< T const > |
C inner_product_fn |
C input_range_tag |
C insert_fn |
C insert_iterator |
C inserter_fn |
C intersperse_view |
C invoke_fn |
C invoke_result |
C iota_fn |
C iota_view |
C is_indirectly_movable |
C is_indirectly_swappable |
C is_nothrow_indirectly_movable |
C is_nothrow_indirectly_swappable |
C istream_view |
C iter_distance_compare_fn |
C iter_distance_fn |
C iter_enumerate_fn |
C iter_size_fn |
C iter_take_while_view |
C iter_transform2_view |
C iter_transform_view |
C iter_zip_with_view |
C iterator_range |
C iterator_wrapper |
C join_view |
C join_with_view |
C lazy_yield_if_fn |
C less |
C less_equal |
C logical_negate |
C make_action_closure_fn |
C make_common_pair_fn |
C make_common_tuple_fn |
C make_compressed_pair_fn |
C make_compressed_tuple_fn |
C make_move_iterator_fn |
C make_move_sentinel_fn |
C make_ostream_joiner_fn |
C make_pipeable_fn |
C make_reverse_iterator_fn |
C make_subrange_fn |
C make_tuple_fn |
C make_view_closure_fn |
C minus |
C move_into_fn |
C move_iterator |
C move_sentinel |
C move_tag |
C move_view |
C multiplies |
C next_fn |
C not_equal_to |
C not_fn_fn |
▼C nullopt_t |
C tag |
C on_fn |
C optional |
C ostream_iterator |
C ostream_joiner |
C ostreambuf_iterator |
C overload_fn |
C overloaded |
C overloaded< First, Rest... > |
C overloaded<> |
C partial_sum_fn |
C partial_sum_view |
▼C pipeable_access |
C impl |
C pipeable_base |
C plus |
C prev_fn |
C protect_fn |
C protector |
C push_back_fn |
C push_front_fn |
C random_access_range_tag |
C range_cardinality |
C range_tag |
C raw_buffer |
C raw_storage_iterator |
C ref_fn |
C ref_view |
C reference_wrapper |
C remove_if_view |
C repeat_n_view |
C repeat_view |
C reverse_view |
C reverse_view< reverse_view< Rng > > |
C sample_view |
C scope_exit |
C semiregular_box |
C semiregular_box< T & > |
C semiregular_box< T && > |
C sentinel_tag |
C single_view |
C sized_iterator_range |
C sized_range_tag |
C sized_sentinel_tag |
C slice_view |
C sliding_view |
C sliding_view< Rng, sliding_view_detail::cache::first > |
C sliding_view< Rng, sliding_view_detail::cache::last > |
C sliding_view< Rng, sliding_view_detail::cache::none > |
C span |
C split_view |
C split_when_view |
C static_const |
C stride_view |
C subrange |
C tail_view |
C take_view |
C take_while_view |
C tokenize_view |
C transform2_view |
C transform_view |
C transformed |
C trim_view |
C tuple_apply_fn |
C tuple_foldl_fn |
C tuple_for_each_fn |
C tuple_transform_fn |
C unbounded_view |
C unreachable_sentinel_t |
C unwrap_reference_fn |
C variant |
C view_adaptor |
C view_base |
▼C view_facade | A utility for constructing a view from a (derived) type that implements begin and end cursors
C view_as_cursor |
C view_interface |
C yield_fn |
C yield_from_fn |
C yield_if_fn |
C zip_view |
C zip_with_view |
▼N std | STL namespace
▼N__1 |
C basic_common_reference |
C basic_common_reference< std::pair< F1, S1 >, ::ranges::common_pair< F2, S2 >, Qual1, Qual2 > |
C basic_common_reference< std::tuple< Ts... >, ::ranges::common_tuple< Us... >, Qual1, Qual2 > |
C basic_common_reference<::ranges::common_pair< F1, S1 >, ::ranges::common_pair< F2, S2 >, Qual1, Qual2 > |
C basic_common_reference<::ranges::common_pair< F1, S1 >, std::pair< F2, S2 >, Qual1, Qual2 > |
C basic_common_reference<::ranges::common_tuple< Ts... >, ::ranges::common_tuple< Us... >, Qual1, Qual2 > |
C basic_common_reference<::ranges::common_tuple< Ts... >, std::tuple< Us... >, Qual1, Qual2 > |
C common_type |
C common_type< std::pair< F1, S1 >, ::ranges::common_pair< F2, S2 > > |
C common_type< std::tuple< Ts... >, ::ranges::common_tuple< Us... > > |
C common_type<::ranges::common_pair< F1, S1 >, ::ranges::common_pair< F2, S2 > > |
C common_type<::ranges::common_pair< F1, S1 >, std::pair< F2, S2 > > |
C common_type<::ranges::common_tuple< Ts... >, ::ranges::common_tuple< Us... > > |
C common_type<::ranges::common_tuple< Ts... >, std::tuple< Us... > > |
C tuple_element< 0, ::ranges::common_pair< First, Second > > |
C tuple_element< 1, ::ranges::common_pair< First, Second > > |
C tuple_element< N, ::ranges::common_tuple< Ts... > > |
C tuple_size<::ranges::common_pair< First, Second > > |
C tuple_size<::ranges::common_tuple< Ts... > > |
C basic_common_reference |
C basic_common_reference< std::pair< F1, S1 >, ::ranges::common_pair< F2, S2 >, Qual1, Qual2 > |
C basic_common_reference< std::tuple< Ts... >, ::ranges::common_tuple< Us... >, Qual1, Qual2 > |
C basic_common_reference<::ranges::common_pair< F1, S1 >, ::ranges::common_pair< F2, S2 >, Qual1, Qual2 > |
C basic_common_reference<::ranges::common_pair< F1, S1 >, std::pair< F2, S2 >, Qual1, Qual2 > |
C basic_common_reference<::ranges::common_tuple< Ts... >, ::ranges::common_tuple< Us... >, Qual1, Qual2 > |
C basic_common_reference<::ranges::common_tuple< Ts... >, std::tuple< Us... >, Qual1, Qual2 > |
C common_type |
C common_type< std::pair< F1, S1 >, ::ranges::common_pair< F2, S2 > > |
C common_type< std::tuple< Ts... >, ::ranges::common_tuple< Us... > > |
C common_type<::ranges::common_pair< F1, S1 >, ::ranges::common_pair< F2, S2 > > |
C common_type<::ranges::common_pair< F1, S1 >, std::pair< F2, S2 > > |
C common_type<::ranges::common_tuple< Ts... >, ::ranges::common_tuple< Us... > > |
C common_type<::ranges::common_tuple< Ts... >, std::tuple< Us... > > |
C tuple_element< 0, ::ranges::common_pair< First, Second > > |
C tuple_element< 1, ::ranges::common_pair< First, Second > > |
C tuple_element< N, ::ranges::common_tuple< Ts... > > |
C tuple_size<::ranges::common_pair< First, Second > > |
C tuple_size<::ranges::common_tuple< Ts... > > |
C iterator_traits<::ranges::basic_iterator< Cur > > |
C tuple_element< 0, ::ranges::compressed_pair< First, Second > > |
C tuple_element< 0, ::ranges::subrange< I, S, K > > |
C tuple_element< 1, ::ranges::compressed_pair< First, Second > > |
C tuple_element< 1, ::ranges::subrange< I, S, K > > |
C tuple_element< I, ::ranges::compressed_tuple_detail::compressed_tuple_< ::meta::list< Ts... >, ::meta::index_sequence< Is... > > > |
C tuple_size<::ranges::compressed_pair< First, Second > > |
C tuple_size<::ranges::compressed_tuple_detail::compressed_tuple_< ::meta::list< Ts... >, ::meta::index_sequence< Is... > > > |
C tuple_size<::ranges::subrange< I, S, K > > |
C ActionFn |
C Derived |
C Pipeable |
C common_ref_tuple_like |
C common_type_tuple_like |
C std_iterator_traits |
C tuple_element |