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

Classes | Typedefs | Enumerations | Functions
ranges::v3 Namespace Reference
Algorithms | Core | Utility | Views

Protect a callable so that it can be safely used in a bind expression without accidentally becoming a "nested" bind. More...

## Classes
struct | accumulate_fn
struct | adaptor_base
struct | adaptor_cursor
struct | adaptor_sentinel
struct | adjacent_difference_fn
struct | adjacent_filter_view
struct | adjacent_find_fn
struct | adjacent_remove_if_view
struct | all_of_fn
struct | any
struct | any_of_fn
struct | any_view
| A type-erased view. More...
struct | as_function_fn
struct | at_fn
struct | back_fn
struct | back_inserter_fn
struct | bad_any_cast
struct | basic_common_reference
| Users can specialize this to hook the `CommonReference` concept. More...
struct | basic_iterator
struct | basic_mixin
struct | basic_sentinel
struct | basic_view
struct | begin_tag
struct | bidirectional_iterator_tag
struct | binary_search_fn
struct | bind_element
struct | bind_element< reference_wrapper< T, RValue > >
struct | bind_element< std::reference_wrapper< T > >
struct | bitwise_or
struct | bounded_view
class | box
class | box< Element, Tag, detail::box_compress::coalesce >
class | box< Element, Tag, detail::box_compress::ebo >
struct | chunk_view
struct | closed_iota_view
| An iota view in a closed range with non-random access iota value type. More...
struct | coerce
struct | coerce< T & >
struct | coerce< T && >
struct | coerce< T const >
struct | common_pair
struct | common_reference
| Users can specialize this to hook the `CommonReference` concept. More...
struct | common_reference< T >
struct | common_reference< T, U >
struct | common_reference< T, U, Vs... >
struct | common_tuple
struct | common_type
| Users should specialize this to hook the `Common` concept until `std` gets a SFINAE-friendly `std::common_type` and there's some sane way to deal with cv and ref qualifiers. More...
struct | common_type< T >
struct | common_type< T, U >
struct | common_type< T, U, Vs... >
struct | compose_fn
struct | composed
struct | compressed_pair
struct | concat_view
struct | const_view
struct | constant
struct | convert_to
struct | copy_backward_fn
struct | copy_fn
struct | copy_if_fn
struct | copy_n_fn
struct | copy_tag
struct | count_fn
struct | count_if_fn
struct | counted_view
struct | cycled_view
struct | dangling
| A wrapper for an iterator or a sentinel into a range that may no longer be valid. More...
struct | dangling< void >
struct | default_end_cursor
struct | delimit_view
struct | difference_type
struct | difference_type< std::nullptr_t >
struct | difference_type< T * >
struct | difference_type< T const >
struct | difference_type< T const volatile >
struct | difference_type< T volatile >
struct | difference_type< T, meta::if_< std::is_array< T > > >
struct | difference_type< T, meta::if_< std::is_integral< T > > >
struct | difference_type< T, meta::void_< typename T::difference_type > >
struct | disable_sized_range
struct | disable_sized_sentinel
struct | distance_compare_fn
struct | distance_fn
struct | drop_exactly_view
struct | drop_view
struct | drop_while_view
struct | empty_fn
struct | empty_view
struct | end_tag
struct | enumerate_fn
struct | equal_fn
struct | equal_range_fn
struct | equal_to
struct | fill_fn
struct | fill_n_fn
struct | filter_view
struct | find_end_fn
struct | find_first_of_fn
struct | find_fn
struct | find_if_fn
struct | find_if_not_fn
struct | for_each_fn
struct | for_each_view
struct | forward_iterator_tag
struct | front_fn
struct | front_inserter_fn
struct | generate_fn
struct | generate_n_fn
struct | generate_n_view
struct | generate_view
struct | get_cursor_fn
| Get a cursor from a basic_iterator. More...
struct | get_unsafe_fn
struct | getlines_fn
struct | getlines_range
struct | group_by_view
struct | ident
struct | includes_fn
struct | indirect_fn
struct | indirect_view
struct | indirected
struct | inner_product_fn
struct | inplace_merge_fn
struct | input_iterator_tag
struct | insert_fn
struct | interleave_view
| Flattens a range of ranges by iterating the inner ranges in round-robin fashion. More...
struct | intersperse_view
struct | iota_fn
struct | iota_view
struct | iota_view< From, void >
struct | is_heap_fn
struct | is_heap_until_fn
struct | is_indirectly_movable
struct | is_indirectly_swappable
struct | is_nothrow_indirectly_movable
struct | is_nothrow_indirectly_swappable
struct | is_nothrow_swappable
struct | is_partitioned_fn
struct | is_permutation_fn
struct | is_pipeable
struct | is_pipeable< T & >
struct | is_reference_wrapper
struct | is_reference_wrapper< reference_wrapper< T, RValue > >
struct | is_reference_wrapper< std::reference_wrapper< T > >
struct | is_sorted_fn
struct | is_sorted_until_fn
struct | is_swappable
struct | is_view
struct | is_view< std::initializer_list< T > >
struct | is_view< std::multiset< Key, Compare, Alloc > >
struct | is_view< std::set< Key, Compare, Alloc > >
struct | is_view< std::unordered_multiset< Key, Hash, Pred, Alloc > >
struct | is_view< std::unordered_set< Key, Hash, Pred, Alloc > >
struct | istream_range
struct | iter_distance_compare_fn
struct | iter_distance_fn
struct | iter_enumerate_fn
struct | iter_move_fn
struct | iter_size_fn
struct | iter_swap_fn
struct | iter_take_while_view
struct | iter_transform2_view
struct | iter_transform_view
struct | iter_zip_with_view
struct | iterator_category
struct | iterator_category< T * >
struct | iterator_category< T const >
struct | iterator_category< T const volatile >
struct | iterator_category< T volatile >
struct | iterator_category< T, meta::void_< typename T::iterator_category > >
struct | iterator_range
struct | join_view
struct | join_view< Rng, void >
struct | lazy_yield_if_fn
struct | less
struct | lexicographical_compare_fn
struct | logical_negate
struct | lower_bound_fn
struct | make_common_pair_fn
struct | make_common_tuple_fn
struct | make_heap_fn
struct | make_iterator_range_fn
struct | make_move_iterator_fn
struct | make_move_sentinel_fn
struct | make_pipeable_fn
struct | make_tuple_fn
struct | max_element_fn
struct | max_fn
struct | merge_fn
struct | min_element_fn
struct | min_fn
struct | minmax_element_fn
struct | minmax_fn
struct | minus
struct | mismatch_fn
struct | move_backward_fn
struct | move_fn
struct | move_into_fn
struct | move_sentinel
struct | move_tag
struct | move_view
struct | multiplies
struct | mutable_
struct | mutable_< std::atomic< T > >
struct | next_fn
struct | next_permutation_fn
struct | none_of_fn
struct | not_equal_to
struct | not_fn
struct | nth_element_fn
struct | on_fn
struct | ordered_less
struct | overload_fn
struct | overloaded
struct | overloaded< First, Rest... >
struct | overloaded<>
struct | partial_sort_copy_fn
struct | partial_sort_fn
struct | partial_sum_fn
struct | partial_sum_view
struct | partition_copy_fn
struct | partition_fn
struct | partition_point_fn
struct | pipeable
struct | pipeable_access
struct | pipeable_base
struct | plus
struct | pop_heap_fn
struct | prev_fn
struct | prev_permutation_fn
struct | protect_fn
struct | push_heap_fn
struct | random_access_iterator_tag
struct | range_cardinality
struct | raw_storage_iterator
struct | ref_fn
struct | reference_of
struct | reference_of< reference_wrapper< T, RValue > >
struct | reference_of< std::reference_wrapper< T > >
struct | reference_of< T & >
struct | reference_of< T && >
struct | reference_of< T const >
struct | reference_wrapper
struct | remove_copy_fn
struct | remove_copy_if_fn
struct | remove_fn
struct | remove_if_fn
struct | remove_if_view
struct | repeat_n_view
struct | repeat_view
struct | replace_copy_fn
struct | replace_copy_if_fn
struct | replace_fn
struct | replace_if_fn
struct | reverse_copy_fn
struct | reverse_fn
struct | reverse_view
struct | rotate_copy_fn
struct | rotate_fn
struct | rref_fn
struct | safe_begin_fn
struct | safe_end_fn
class | sample_fn
class | sample_view
struct | sanitize_fn
struct | search_fn
struct | search_n_fn
struct | semiregular
struct | set_difference_fn
struct | set_intersection_fn
struct | set_symmetric_difference_fn
struct | set_union_fn
struct | shuffle_fn
struct | single_view
struct | size_type
struct | sized_iterator_range
struct | slice_view
struct | sort_fn
struct | sort_heap_fn
struct | split_view
struct | stable_partition_fn
struct | stable_sort_fn
struct | static_const
struct | stride_view
struct | swap_ranges_fn
struct | tail_view
struct | take_view
struct | take_while_view
struct | tokenize_view
struct | transform2_view
struct | transform_fn
struct | transform_view
struct | transformed
struct | tuple_apply_fn
struct | tuple_foldl_fn
struct | tuple_for_each_fn
struct | tuple_transform_fn
struct | unbounded_view
struct | unique_copy_fn
struct | unique_fn
struct | unreachable
struct | unwrap_reference_fn
struct | upper_bound_fn
struct | value_type
struct | value_type< T * >
struct | value_type< T const >
struct | value_type< T const volatile >
struct | value_type< T volatile >
struct | value_type< T, meta::if_< std::is_array< T > > >
struct | value_type< T, meta::if_< std::is_base_of< std::ios_base, T > > >
struct | value_type< T, meta::void_< typename T::element_type > >
struct | value_type< T, meta::void_< typename T::value_type > >
struct | variant
struct | view_adaptor
struct | view_base
struct | view_facade
struct | view_interface
struct | with_braced_init_args
struct | yield_fn
struct | yield_from_fn
struct | yield_if_fn
struct | zip_view
struct | zip_with_view

## Typedefs
template<typename I , typename T , typename Op = plus, typename P = ident, typename V = iterator_value_t<I>, typename X = concepts::Callable::result_t<P, V>, typename Y = concepts::Callable::result_t<Op, T, X>>
using | Accumulateable = meta::strict_and< InputIterator< I >, Callable< P, V >, Callable< Op, T, X >, Assignable< T &, Y >>
template<typename D >
using | adaptor_cursor_t = adaptor_cursor< detail::adapted_iterator_t< D >, detail::begin_adaptor_t< D >>
template<typename D >
using | adaptor_sentinel_t = meta::if_< meta::and_< Same< detail::adapted_iterator_t< D >, detail::adapted_sentinel_t< D >>, Same< detail::begin_adaptor_t< D >, detail::end_adaptor_t< D >>>, adaptor_cursor< detail::adapted_iterator_t< D >, detail::begin_adaptor_t< D >>, adaptor_sentinel< detail::adapted_sentinel_t< D >, detail::end_adaptor_t< D >>>
template<typename I , typename O , typename BOp = minus, typename P = ident, typename V = iterator_value_t<I>, typename X = concepts::Callable::result_t<P, V>, typename Y = concepts::Callable::result_t<BOp, X, X>>
using | AdjacentDifferentiable = meta::strict_and< InputIterator< I >, OutputIterator< O, X && >, OutputIterator< O, Y && >, Callable< P, V >, Callable< BOp, X, X >, CopyConstructible< uncvref_t< X >>, Movable< uncvref_t< X >>>
template<typename Ref >
using | any_bidirectional_view = any_view< Ref, category::bidirectional >
template<typename Ref >
using | any_forward_view = any_view< Ref, category::forward >
template<typename Ref >
using | any_input_view = any_view< Ref, category::input >
template<typename Ref >
using | any_random_access_view = any_view< Ref, category::random_access >
template<typename T , typename U >
using | Assignable = concepts::models< concepts::Assignable, T, U >
template<typename I1 , typename I2 , typename C = equal_to, typename P1 = ident, typename P2 = ident>
using | AsymmetricallyComparable = meta::strict_and< InputIterator< I1 >, InputIterator< I2 >, IndirectCallablePredicate< C, projected< I1, P1 >, projected< I2, P2 >>>
template<typename Cont >
using | back_insert_iterator = basic_iterator< detail::back_insert_cursor< Cont >>
template<typename Derived >
using | base_range_t = meta::_t< range_access::base_range< Derived >>
template<typename T >
using | BidirectionalIncrementable = concepts::models< concepts::BidirectionalIncrementable, T >
template<typename I >
using | BidirectionalIterator = concepts::models< concepts::BidirectionalIterator, I >
template<typename T >
using | BidirectionalRange = concepts::models< concepts::BidirectionalRange, T >
template<typename T >
using | BidirectionalView = concepts::models< concepts::BidirectionalView, T >
template<typename I , typename V2 , typename C = ordered_less, typename P = ident>
using | BinarySearchable = meta::strict_and< ForwardIterator< I >, IndirectCallableRelation< C, projected< I, P >, V2 const * >>
template<typename T >
using | bind_element_t = meta::_t< bind_element< T >>
template<typename T >
using | bounded_range_concept = concepts::most_refined< meta::list< concepts::BoundedRange, concepts::Range >, T >
template<typename T >
using | bounded_range_concept_t = meta::_t< bounded_range_concept< T >>
template<typename T >
using | bounded_view_concept = concepts::most_refined< meta::list< concepts::BoundedView, concepts::View >, T >
template<typename T >
using | bounded_view_concept_t = meta::_t< bounded_view_concept< T >>
template<typename T >
using | BoundedRange = concepts::models< concepts::BoundedRange, T >
template<typename T >
using | BoundedView = concepts::models< concepts::BoundedView, T >
template<typename Fun , typename... Args>
using | Callable = concepts::models< concepts::Callable, Fun, Args... >
template<typename Fun , typename... Args>
using | CallablePredicate = concepts::models< concepts::CallablePredicate, Fun, Args... >
template<typename Fun , typename T , typename U = T>
using | CallableRelation = concepts::models< concepts::CallableRelation, Fun, T, U >
template<typename T , typename U , typename... Rest>
using | Common = meta::or_< meta::strict_and< std::is_void< T >, std::is_void< U >, std::is_void< Rest >... >, concepts::models< concepts::Common, T, U, Rest... >>
template<typename I , typename S >
using | common_iterator = meta::if_< std::is_same< I, S >, I, basic_iterator< detail::common_cursor< I, S >>>
template<typename... Ts>
using | common_reference_t = meta::_t< common_reference< Ts... >>
template<typename... Ts>
using | common_type_t = meta::_t< common_type< Ts... >>
template<typename T , typename U , typename... Rest>
using | CommonReference = meta::or_< meta::strict_and< std::is_void< T >, std::is_void< U >, std::is_void< Rest >... >, concepts::models< concepts::CommonReference, T, U, Rest... >>
template<typename I1 , typename I2 , typename C = equal_to, typename P1 = ident, typename P2 = ident>
using | Comparable = meta::strict_and< AsymmetricallyComparable< I1, I2, C, P1, P2 >, IndirectCallableRelation< C, projected< I1, P1 >, projected< I2, P2 >>>
template<typename T , typename... Args>
using | Constructible = concepts::models< concepts::Constructible, T, Args... >
template<typename T >
using | Container = concepts::models< concepts::Container, T >
template<typename T >
using | ContainerLike_ = concepts::models< concepts::ContainerLike_, T >
| INTERNAL ONLY.
template<typename T , typename U >
using | ConvertibleTo = concepts::models< concepts::ConvertibleTo, T, U >
template<typename T >
using | Copyable = concepts::models< concepts::Copyable, T >
template<typename T >
using | CopyConstructible = concepts::models< concepts::CopyConstructible, T >
template<typename I , typename D = meta::_t<difference_type<I>>>
using | counted_iterator = basic_iterator< detail::counted_cursor< I, D >, default_end_cursor >
using | default_sentinel = basic_sentinel< default_end_cursor >
template<typename T >
using | DefaultConstructible = concepts::models< concepts::DefaultConstructible, T >
template<typename T , typename U >
using | DerivedFrom = concepts::models< concepts::DerivedFrom, T, U >
template<typename T >
using | Destructible = concepts::models< concepts::Destructible, T >
template<typename T , typename U = T>
using | EqualityComparable = concepts::models< concepts::EqualityComparable, T, U >
template<typename Rng , typename... Rest>
using | ErasableRange = concepts::models< concepts::ErasableRange, Rng, Rest... >
template<typename I , typename T >
using | ExclusivelyWritable_ = meta::invoke< detail::exclusively_writable_< I >, T >
template<typename T , typename U >
using | ExplicitlyConvertibleTo = concepts::models< concepts::ExplicitlyConvertibleTo, T, U >
template<typename I >
using | ForwardIterator = concepts::models< concepts::ForwardIterator, I >
template<typename T >
using | ForwardRange = concepts::models< concepts::ForwardRange, T >
template<typename T >
using | ForwardView = concepts::models< concepts::ForwardView, T >
template<typename Cont >
using | front_insert_iterator = basic_iterator< detail::front_insert_cursor< Cont >>
template<typename Fun , typename... Args>
using | Function = concepts::models< concepts::Function, Fun, Args... >
template<typename T >
using | function_type = decltype(as_function(std::declval< T >()))
template<typename T , typename U >
using | ImplicitlyConvertibleTo = concepts::models< concepts::ImplicitlyConvertibleTo, T, U >
template<typename T >
using | Incrementable = concepts::models< concepts::Incrementable, T >
template<typename T >
using | incrementable_concept = concepts::most_refined< meta::list< concepts::RandomAccessIncrementable, concepts::BidirectionalIncrementable, concepts::Incrementable, concepts::WeaklyIncrementable >, T >
template<typename T >
using | incrementable_concept_t = meta::_t< incrementable_concept< T >>
template<typename C , typename... Is>
using | IndirectCallable = IndirectFunction< function_type< C >, Is... >
template<typename C , typename... Is>
using | IndirectCallablePredicate = IndirectPredicate< function_type< C >, Is... >
template<typename C , typename I0 , typename I1 = I0>
using | IndirectCallableRelation = IndirectRelation< function_type< C >, I0, I1 >
template<typename C , typename... Is>
using | IndirectFunction = meta::and_< meta::strict_and< Readable< Is >... >, meta::lazy::invoke< detail::iter_map_reduce_fn_< meta::bind_front< meta::quote< Function >, C >, meta::quote< meta::strict_and >>, Is... >, meta::lazy::invoke< detail::iter_map_reduce_fn_< meta::bind_front< meta::quote< concepts::Function::result_t >, C >, meta::quote< CommonReference >>, Is... > >
template<typename I , typename O >
using | IndirectlyCopyable = concepts::models< concepts::IndirectlyCopyable, I, O >
template<typename I , typename O >
using | IndirectlyCopyableStorable = concepts::models< concepts::IndirectlyCopyableStorable, I, O >
template<typename I , typename O >
using | IndirectlyMovable = concepts::models< concepts::IndirectlyMovable, I, O >
template<typename I , typename O >
using | IndirectlyMovableStorable = concepts::models< concepts::IndirectlyMovableStorable, I, O >
template<typename I1 , typename I2 >
using | IndirectlySwappable = concepts::models< concepts::IndirectlySwappable, I1, I2 >
template<typename C , typename... Is>
using | IndirectPredicate = meta::and_< meta::strict_and< Readable< Is >... >, meta::lazy::invoke< detail::iter_map_reduce_fn_< meta::bind_front< meta::quote< Predicate >, C >, meta::quote< meta::strict_and >>, Is... >>
template<typename C , typename I0 , typename I1 = I0>
using | IndirectRelation = meta::and_< meta::strict_and< Readable< I0 >, Readable< I1 >>, meta::lazy::invoke< detail::iter_map_reduce_fn_< meta::bind_front< meta::quote< Relation >, C >, meta::quote< meta::strict_and >>, I0, I1 >>
template<typename I1 , typename I2 , typename T , typename BOp1 = plus, typename BOp2 = multiplies, typename P1 = ident, typename P2 = ident, typename V1 = iterator_value_t<I1>, typename V2 = iterator_value_t<I2>, typename X1 = concepts::Callable::result_t<P1, V1>, typename X2 = concepts::Callable::result_t<P2, V2>, typename Y2 = concepts::Callable::result_t<BOp2, X1, X2>, typename Y1 = concepts::Callable::result_t<BOp1, T, Y2>>
using | InnerProductable = meta::strict_and< InputIterator< I1 >, InputIterator< I2 >, Callable< P1, V1 >, Callable< P2, V2 >, Callable< BOp2, X1, X2 >, Callable< BOp1, T, Y2 >, Assignable< T &, Y2 >>
template<typename I >
using | InputIterator = concepts::models< concepts::InputIterator, I >
template<typename T >
using | InputRange = concepts::models< concepts::InputRange, T >
template<typename T >
using | InputView = concepts::models< concepts::InputView, T >
template<typename T >
using | Integral = concepts::models< concepts::Integral, T >
template<typename Rng >
using | is_finite = meta::bool_< range_cardinality< Rng >::value >=finite >
template<typename Rng >
using | is_infinite = meta::bool_< range_cardinality< Rng >::value==infinite >
template<typename T >
using | is_reference_wrapper_t = meta::_t< is_reference_wrapper< T >>
template<typename I , typename C = ordered_less, typename P = ident>
using | IsHeapable = meta::strict_and< RandomAccessIterator< I >, IndirectCallableRelation< C, projected< I, P >>>
template<typename I , typename C , typename P = ident>
using | IsPartitionedable = meta::strict_and< InputIterator< I >, IndirectCallablePredicate< C, projected< I, P >>>
template<typename I1 , typename I2 , typename C = equal_to, typename P1 = ident, typename P2 = ident>
using | IsPermutationable = meta::strict_and< ForwardIterator< I1 >, ForwardIterator< I2 >, Comparable< I1, I2, C, P1, P2 >>
template<typename I >
using | Iterator = concepts::models< concepts::Iterator, I >
template<typename I >
using | iterator_category_t = concepts::InputIterator::category_t< I >
template<typename I >
using | iterator_common_reference = meta::defer< iterator_common_reference_t, I >
template<typename I >
using | iterator_common_reference_t = concepts::Readable::common_reference_t< I >
template<typename T >
using | iterator_concept = concepts::most_refined< meta::list< concepts::RandomAccessIterator, concepts::BidirectionalIterator, concepts::ForwardIterator, concepts::InputIterator >, T >
template<typename T >
using | iterator_concept_t = meta::_t< iterator_concept< T >>
template<typename I >
using | iterator_difference = meta::defer< iterator_difference_t, I >
template<typename I >
using | iterator_difference_t = concepts::WeaklyIncrementable::difference_t< I >
template<typename I >
using | iterator_reference = meta::defer< iterator_reference_t, I >
template<typename I >
using | iterator_reference_t = concepts::Readable::reference_t< I >
template<typename I >
using | iterator_rvalue_reference = meta::defer< iterator_rvalue_reference_t, I >
template<typename I >
using | iterator_rvalue_reference_t = concepts::Readable::rvalue_reference_t< I >
template<typename I >
using | iterator_size = meta::defer< iterator_size_t, I >
template<typename I >
using | iterator_size_t = meta::_t< std::make_unsigned< iterator_difference_t< I >>>
template<typename I >
using | iterator_value = meta::defer< iterator_value_t, I >
template<typename I >
using | iterator_value_t = concepts::Readable::value_t< I >
template<typename I , typename S >
using | IteratorRange = Sentinel< S, I >
template<typename Rng >
using | keys_range_view = transform_view< Rng, detail::get_first >
template<typename T >
using | LvalueContainerLike = concepts::models< concepts::LvalueContainerLike, T >
template<typename I0 , typename I1 , typename Out , typename C = ordered_less, typename P0 = ident, typename P1 = ident>
using | Mergeable = meta::strict_and< InputIterator< I0 >, InputIterator< I1 >, WeaklyIncrementable< Out >, IndirectCallableRelation< C, projected< I0, P0 >, projected< I1, P1 >>, IndirectlyCopyable< I0, Out >, IndirectlyCopyable< I1, Out >>
template<typename I1 , typename I2 , typename C = equal_to, typename P1 = ident, typename P2 = ident>
using | Mismatchable = meta::strict_and< InputIterator< I1 >, InputIterator< I2 >, IndirectCallablePredicate< C, projected< I1, P1 >, projected< I2, P2 >>>
template<typename T >
using | Movable = concepts::models< concepts::Movable, T >
template<typename I >
using | move_into_iterator = basic_iterator< detail::move_into_cursor< I >, default_end_cursor >
template<typename I >
using | move_iterator = basic_iterator< detail::move_cursor< I >, default_end_cursor >
template<typename T >
using | MoveConstructible = concepts::models< concepts::MoveConstructible, T >
template<typename I0 , typename I1 , typename Out , typename C = ordered_less, typename P0 = ident, typename P1 = ident>
using | MoveMergeable = meta::strict_and< InputIterator< I0 >, InputIterator< I1 >, WeaklyIncrementable< Out >, IndirectCallableRelation< C, projected< I0, P0 >, projected< I1, P1 >>, IndirectlyMovable< I0, Out >, IndirectlyMovable< I1, Out >>
template<typename Out , typename T >
using | OutputIterator = concepts::models< concepts::OutputIterator, Out, T >
template<typename T , typename V >
using | OutputRange = concepts::models< concepts::OutputRange, T, V >
template<typename T , typename V >
using | OutputView = concepts::models< concepts::OutputView, T, V >
template<typename I , typename O , typename C = ordered_less, typename PI = ident, typename PO = ident>
using | PartialSortCopyConcept = meta::strict_and< InputIterator< I >, RandomAccessIterator< O >, IndirectlyCopyable< I, O >, IndirectCallableRelation< C, projected< I, PI >, projected< O, PO >>, Sortable< O, C, PO >>
template<typename I , typename O , typename BOp = plus, typename P = ident, typename V = iterator_value_t<I>, typename X = concepts::Callable::result_t<P, V>, typename Y = concepts::Callable::result_t<BOp, X, X>>
using | PartialSummable = meta::strict_and< InputIterator< I >, OutputIterator< O, X && >, Callable< P, V >, CopyConstructible< uncvref_t< X >>, Callable< BOp, X, X >, Assignable< uncvref_t< X > &, Y >>
template<typename I , typename C , typename P = ident>
using | Partitionable = meta::strict_and< ForwardIterator< I >, Permutable< I >, IndirectCallablePredicate< C, projected< I, P >>>
template<typename I , typename O0 , typename O1 , typename C , typename P = ident>
using | PartitionCopyable = meta::strict_and< InputIterator< I >, WeaklyIncrementable< O0 >, WeaklyIncrementable< O1 >, IndirectlyCopyable< I, O0 >, IndirectlyCopyable< I, O1 >, IndirectCallablePredicate< C, projected< I, P >>>
template<typename I , typename V = concepts::Readable::value_t<I>>
using | Permutable = meta::strict_and< ForwardIterator< I >, IndirectlySwappable< I, I >, IndirectlyMovableStorable< I, I >>
template<typename Fun , typename... Args>
using | Predicate = concepts::models< concepts::Predicate, Fun, Args... >
template<typename I , typename Proj >
using | projected = meta::if_< IndirectCallable< Proj, I >, detail::projected_readable< I, Proj >>
template<typename T >
using | RandomAccessIncrementable = concepts::models< concepts::RandomAccessIncrementable, T >
template<typename I >
using | RandomAccessIterator = concepts::models< concepts::RandomAccessIterator, I >
template<typename T >
using | RandomAccessRange = concepts::models< concepts::RandomAccessRange, T >
template<typename C >
using | RandomAccessReservable = meta::strict_and< Reservable< C >, RandomAccessRange< C >>
template<typename T >
using | RandomAccessView = concepts::models< concepts::RandomAccessView, T >
template<typename T >
using | Range = concepts::models< concepts::Range, T >
template<typename Rng >
using | range_category = meta::defer< range_category_t, Rng >
template<typename Rng >
using | range_category_t = concepts::InputRange::category_t< Rng >
template<typename Rng >
using | range_common_iterator_t = common_iterator< range_iterator_t< Rng >, range_sentinel_t< Rng >>
template<typename Rng >
using | range_common_reference = meta::defer< range_common_reference_t, Rng >
template<typename Rng >
using | range_common_reference_t = concepts::InputRange::common_reference_t< Rng >
template<typename T >
using | range_concept = concepts::most_refined< meta::list< concepts::RandomAccessRange, concepts::BidirectionalRange, concepts::ForwardRange, concepts::InputRange >, T >
template<typename T >
using | range_concept_t = meta::_t< range_concept< T >>
template<typename Rng >
using | range_difference = meta::defer< range_difference_t, Rng >
template<typename Rng >
using | range_difference_t = concepts::Range::difference_t< Rng >
template<typename Rng >
using | range_iterator = meta::defer< range_iterator_t, Rng >
template<typename Rng >
using | range_iterator_t = concepts::Range::iterator_t< Rng >
template<typename Rng >
using | range_reference = meta::defer< range_reference_t, Rng >
template<typename Rng >
using | range_reference_t = concepts::InputRange::reference_t< Rng >
template<typename Rng >
using | range_rvalue_reference = meta::defer< range_rvalue_reference_t, Rng >
template<typename Rng >
using | range_rvalue_reference_t = concepts::InputRange::rvalue_reference_t< Rng >
template<typename Rng >
using | range_safe_iterator_t = decltype(ranges::safe_begin(std::declval< Rng >()))
template<typename Rng >
using | range_safe_sentinel_t = decltype(ranges::safe_end(std::declval< Rng >()))
template<typename Rng >
using | range_sentinel = meta::defer< range_sentinel_t, Rng >
template<typename Rng >
using | range_sentinel_t = concepts::Range::sentinel_t< Rng >
template<typename Rng >
using | range_size = meta::defer< range_size_t, Rng >
template<typename Rng >
using | range_size_t = meta::_t< std::make_unsigned< range_difference_t< Rng >>>
template<typename Rng >
using | range_value = meta::defer< range_value_t, Rng >
template<typename Rng >
using | range_value_t = concepts::InputRange::value_t< Rng >
template<typename T >
using | Readable = concepts::models< concepts::Readable, T >
template<typename T >
using | ref_t = decltype(ref(std::declval< T >()))
template<typename T >
using | reference_of_t = meta::_t< reference_of< T >>
template<typename T >
using | Regular = concepts::models< concepts::Regular, T >
template<typename Fun , typename... Args>
using | RegularCallable = concepts::models< concepts::RegularCallable, Fun, Args... >
template<typename Fun , typename... Args>
using | RegularFunction = concepts::models< concepts::RegularFunction, Fun, Args... >
template<typename Fun , typename T , typename U = T>
using | Relation = concepts::models< concepts::Relation, Fun, T, U >
template<typename I , typename T , typename P = ident>
using | Removable = meta::strict_and< ForwardIterator< I >, IndirectCallableRelation< equal_to, projected< I, P >, T const * >, Permutable< I >>
template<typename I , typename C , typename P = ident>
using | RemovableIf = meta::strict_and< ForwardIterator< I >, IndirectCallablePredicate< C, projected< I, P >>, Permutable< I >>
template<typename I , typename O , typename T , typename P = ident>
using | RemoveCopyable = meta::strict_and< InputIterator< I >, WeaklyIncrementable< O >, IndirectCallableRelation< equal_to, projected< I, P >, T const * >, IndirectlyCopyable< I, O >>
template<typename I , typename O , typename C , typename P = ident>
using | RemoveCopyableIf = meta::strict_and< InputIterator< I >, WeaklyIncrementable< O >, IndirectCallablePredicate< C, projected< I, P >>, IndirectlyCopyable< I, O >>
template<typename Rng , typename Pred , typename Val >
using | replace_if_view = iter_transform_view< Rng, detail::replacer_if_fn< Pred, Val >>
template<typename Rng , typename Val1 , typename Val2 >
using | replace_view = iter_transform_view< Rng, detail::replacer_fn< Val1, Val2 >>
template<typename I , typename T0 , typename T1 , typename P = ident>
using | Replaceable = meta::strict_and< InputIterator< I >, IndirectCallableRelation< equal_to, projected< I, P >, T0 const * >, Writable< I, T1 const & >>
template<typename I , typename O , typename T0 , typename T1 , typename P = ident>
using | ReplaceCopyable = meta::strict_and< InputIterator< I >, OutputIterator< O, T1 const & >, IndirectlyCopyable< I, O >, IndirectCallableRelation< equal_to, projected< I, P >, T0 const * >>
template<typename I , typename O , typename C , typename T , typename P = ident>
using | ReplaceCopyIfable = meta::strict_and< InputIterator< I >, OutputIterator< O, T const & >, IndirectlyCopyable< I, O >, IndirectCallablePredicate< C, projected< I, P >>>
template<typename I , typename C , typename T , typename P = ident>
using | ReplaceIfable = meta::strict_and< InputIterator< I >, IndirectCallablePredicate< C, projected< I, P >>, Writable< I, T const & >>
template<typename C >
using | Reservable = concepts::models< concepts::Reservable, C >
template<typename C , typename I >
using | ReserveAndAssignable = concepts::models< concepts::ReserveAndAssignable, C, I >
template<typename Sig >
using | result_of_t = meta::_t< std::result_of< Sig >>
template<typename I >
using | reverse_iterator = basic_iterator< detail::reverse_cursor< I >, detail::reverse_cursor< I >>
template<typename I , typename O >
using | ReverseCopyable = meta::strict_and< BidirectionalIterator< I >, WeaklyIncrementable< O >, IndirectlyCopyable< I, O >>
template<typename T >
using | rref_t = decltype(rref(std::declval< T >()))
template<typename T >
using | rvalue_reference_wrapper = reference_wrapper< T, true >
template<typename... Ts>
using | Same = concepts::Same::same_t< Ts... >
template<typename I1 , typename I2 , typename C = equal_to, typename P1 = ident, typename P2 = ident>
using | Searchable = meta::strict_and< ForwardIterator< I1 >, ForwardIterator< I2 >, Comparable< I1, I2, C, P1, P2 >>
template<typename I , typename V , typename C = equal_to, typename P = ident>
using | Searchnable = meta::strict_and< ForwardIterator< I >, IndirectCallableRelation< C, projected< I, P >, V const * >>
| ingroup group-concepts
template<typename T >
using | SemiContainer = concepts::models< concepts::SemiContainer, T >
template<typename T >
using | SemiRegular = concepts::models< concepts::SemiRegular, T >
template<typename T , bool IsConst = false>
using | semiregular_ref_or_val_t = meta::if_< SemiRegular< T >, meta::if_c< IsConst, T, reference_wrapper< T > >, reference_wrapper< meta::if_c< IsConst, semiregular< T > const, semiregular< T >>>>
template<typename T >
using | semiregular_t = meta::if_< SemiRegular< T >, T, semiregular< T >>
template<typename S , typename I >
using | Sentinel = concepts::models< concepts::Sentinel, S, I >
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 >
using | set_difference_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_difference_cursor, detail::set_difference_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)>
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 >
using | set_intersection_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_intersection_cursor, detail::set_intersection_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)>
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 >
using | set_symmetric_difference_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_symmetric_difference_cursor, detail::set_symmetric_difference_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)>
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 >
using | set_union_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_union_cursor, detail::set_union_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)>
template<typename T >
using | SignedIntegral = concepts::models< concepts::SignedIntegral, T >
template<typename I >
using | SinglePass = meta::strict_and< Iterator< I >, meta::not_< ForwardIterator< I >>>
template<typename T >
using | sized_range_concept = concepts::most_refined< meta::list< concepts::SizedRange, concepts::Range >, T >
template<typename T >
using | sized_range_concept_t = meta::_t< sized_range_concept< T >>
template<typename S , typename I >
using | sized_sentinel_concept = concepts::most_refined< meta::list< concepts::SizedSentinel, concepts::Sentinel >, S, I >
template<typename S , typename I >
using | sized_sentinel_concept_t = meta::_t< sized_sentinel_concept< S, I >>
template<typename T >
using | sized_view_concept = concepts::most_refined< meta::list< concepts::SizedView, concepts::View >, T >
template<typename T >
using | sized_view_concept_t = meta::_t< sized_view_concept< T >>
template<typename I , typename S >
using | SizedIteratorRange = SizedSentinel< S, I >
template<typename T >
using | SizedRange = concepts::models< concepts::SizedRange, T >
template<typename S , typename I >
using | SizedSentinel = concepts::models< concepts::SizedSentinel, S, I >
template<typename T >
using | SizedView = concepts::models< concepts::SizedView, T >
template<typename I , typename C = ordered_less, typename P = ident>
using | Sortable = meta::strict_and< ForwardIterator< I >, IndirectCallableRelation< C, projected< I, P >, projected< I, P >>, Permutable< I >>
template<typename I , typename C , typename P = ident>
using | StablePartitionable = meta::strict_and< ForwardIterator< I >, Permutable< I >, IndirectCallablePredicate< C, projected< I, P >>>
template<typename T , typename U = T>
using | Swappable = concepts::models< concepts::Swappable, T, U >
template<typename F , typename S >
using | tagged_pair = tagged< std::pair< detail::tag_elem< F >, detail::tag_elem< S >>, detail::tag_spec< F >, detail::tag_spec< S >>
template<typename... Ts>
using | tagged_tuple = tagged< std::tuple< detail::tag_elem< Ts >... >, detail::tag_spec< Ts >... >
template<typename Rng >
using | take_exactly_view = detail::take_exactly_view_< Rng >
template<typename T , typename U = T>
using | TotallyOrdered = concepts::models< concepts::TotallyOrdered, T, U >
template<typename I , typename O , typename F , typename P = ident, typename V = iterator_common_reference_t<I>, typename X = concepts::Callable::result_t<P, V>, typename Y = concepts::Callable::result_t<F, X>>
using | Transformable1 = meta::strict_and< InputIterator< I >, WeaklyIncrementable< O >, IndirectCallable< F, projected< I, P >>, Writable< O, Y && >>
template<typename I0 , typename I1 , typename O , typename F , typename P0 = ident, typename P1 = ident, typename V0 = iterator_common_reference_t<I0>, typename X0 = concepts::Callable::result_t<P0, V0>, typename V1 = iterator_common_reference_t<I1>, typename X1 = concepts::Callable::result_t<P1, V1>, typename Y = concepts::Callable::result_t<F, X0, X1>>
using | Transformable2 = meta::strict_and< InputIterator< I0 >, InputIterator< I1 >, WeaklyIncrementable< O >, IndirectCallable< F, projected< I0, P0 >, projected< I1, P1 >>, Writable< O, Y && >>
template<typename Tup >
using | tuple_indices_t = meta::make_index_sequence< std::tuple_size< typename std::remove_reference< Tup >::type >::value >
template<typename T >
using | uncvref_t = meta::_t< std::remove_cv< meta::_t< std::remove_reference< T >>>>
template<typename Gen >
using | UniformRandomNumberGenerator = concepts::models< concepts::UniformRandomNumberGenerator, Gen >
template<typename Rng >
using | unique_view = adjacent_filter_view< Rng, not_equal_to >
template<typename I , typename O , typename C = equal_to, typename P = ident>
using | UniqueCopyable = meta::strict_and< InputIterator< I >, IndirectCallableRelation< C, projected< I, P >>, WeaklyIncrementable< O >, IndirectlyCopyable< I, O >, meta::strict_or< ForwardIterator< I >, ForwardIterator< O >, IndirectlyCopyableStorable< I, O >>>
template<typename T >
using | UnsignedIntegral = concepts::models< concepts::UnsignedIntegral, T >
template<typename T >
using | unwrap_reference_t = decltype(unwrap_reference(std::declval< T >()))
template<typename Rng >
using | values_view = transform_view< Rng, detail::get_second >
template<typename T >
using | View = concepts::models< concepts::View, T >
template<typename T >
using | view_concept = concepts::most_refined< meta::list< concepts::View, concepts::Range >, T >
template<typename T >
using | view_concept_t = meta::_t< view_concept< T >>
template<typename RangeFacade >
using | view_facade_t = meta::_t< range_access::view_facade< RangeFacade >>
template<typename T , typename U >
using | WeaklyEqualityComparable = concepts::models< concepts::WeaklyEqualityComparable, T, U >
template<typename T >
using | WeaklyIncrementable = concepts::models< concepts::WeaklyIncrementable, T >
template<typename T , typename U = T>
using | WeaklyOrdered = concepts::models< concepts::WeaklyOrdered, T, U >
template<typename Out , typename T >
using | Writable = concepts::models< concepts::Writable, Out, T >

## Enumerations
enum | cardinality { infinite = -3, unknown = -2, finite = -1, _max_ = INT_MAX }
enum | category { input, forward, bidirectional, random_access }

## Functions
template<typename T >
constexpr T * | _nullptr_v ()
template<typename T >
meta::if_c< std::is_reference< T >)||Copyable< T >), T > | any_cast (any &)
template<typename T >
meta::if_c< std::is_reference< T >)||Copyable< T >), T > | any_cast (any const &)
template<typename T >
meta::if_c< std::is_reference< T >)||Copyable< T >), T > | any_cast (any &&)
template<typename T >
T * | any_cast (any *) noexcept
template<typename T >
T const * | any_cast (any const *) noexcept
template<typename T , typename U = meta::if_< std::is_lvalue_reference<T>, std::reference_wrapper<meta::_t<std::remove_reference<T>>>, T &&>>
U | bind_forward (meta::_t< std::remove_reference< T >> &t) noexcept
template<typename T >
T && | bind_forward (meta::_t< std::remove_reference< T >> &&t) noexcept
template<typename T >
T & | get (meta::id_t< T > &value)
template<typename T >
T const & | get (meta::id_t< T > const &value)
template<typename T >
T && | get (meta::id_t< T > &&value)
template<typename T >
T & | get (meta::id_t< semiregular< T >> &t)
template<typename T >
T const & | get (meta::id_t< semiregular< T >> const &t)
template<typename T >
T && | get (meta::id_t< semiregular< T >> &&t)
template<std::size_t N, typename I , typename S , int _concept_requires___LINE__ = 42>
constexpr auto | get (sized_iterator_range< I, S > const &p) -> decltype(ranges::get< N >(static_cast< iterator_range< I, S > const & >(p)))
| Tuple-like access for `sized_iterator_range`
template<std::size_t N, typename I , typename S , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(N==2), int >::type = 0>
constexpr iterator_size_t< I > | get (sized_iterator_range< I, S > const &p)
template<typename Tag , typename Element , detail::box_compress BC>
Element & | get (box< Element, Tag, BC > &b) noexcept
template<typename Tag , typename Element , detail::box_compress BC>
constexpr Element const & | get (box< Element, Tag, BC > const &b) noexcept
template<typename Tag , typename Element , detail::box_compress BC>
Element && | get (box< Element, Tag, BC > &&b) noexcept
template<std::size_t I, typename Element , detail::box_compress BC>
Element & | get (box< Element, meta::size_t< I >, BC > &b) noexcept
template<std::size_t I, typename Element , detail::box_compress BC>
constexpr Element const & | get (box< Element, meta::size_t< I >, BC > const &b) noexcept
template<std::size_t I, typename Element , detail::box_compress BC>
Element && | get (box< Element, meta::size_t< I >, BC > &&b) noexcept
template<typename Cont , typename P , typename I , typename S , typename C = common_iterator<I, S>, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(LvalueContainerLike< Cont >()&&Iterator< P >()&&Sentinel< S, I >()), int >::type = 0>
auto | insert (Cont &&cont, P p, I i, S j) -> decltype(detail::insert_impl(std::forward< Cont >(cont), std::move(p), std::move(i), std::move(j), meta::strict_and< RandomAccessReservable< Cont >, SizedSentinel< S, I >>
template<typename Cont , typename I , typename Rng , typename C = range_common_iterator_t<Rng>, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(LvalueContainerLike< Cont >()&&Iterator< I >()&&Range< Rng >()), int >::type = 0>
auto | insert (Cont &&cont, I p, Rng &&rng) -> decltype(detail::insert_impl(std::forward< Cont >(cont), std::move(p), std::forward< Rng >(rng), meta::strict_and< RandomAccessReservable< Cont >, SizedRange< Rng >>
template<typename Val >
istream_range< Val > | istream (std::istream &sin)
template<typename T >
istream_range< T > | istream (std::istream &sin)
template<typename I , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(Iterator< I >()), int >::type = 0>
counted_iterator< I > | make_counted_iterator (I i, iterator_difference_t< I > n)
template<typename V , typename I , typename D >
counted_iterator< raw_storage_iterator< I, V >, detail::external_count< D > > | make_counted_raw_storage_iterator (I i, D &d)
template<typename I >
reverse_iterator< I > | make_reverse_iterator (I i)
template<typename Tag1 , typename Tag2 , typename T1 , typename T2 , typename R = tagged_pair<Tag1(bind_element_t<T1>), Tag2(bind_element_t<T2>)>>
constexpr R | make_tagged_pair (T1 &&t1, T2 &&t2) noexcept(std::is_nothrow_constructible< R, T1, T2 >::value)
template<typename... Tags, typename... Ts>
constexpr tagged_tuple< Tags(bind_element_t< Ts >)... > | make_tagged_tuple (Ts &&...ts)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) EqualityComparable< Ts, Us >()... >::value), int >::type = 0>
bool | operator!= (common_tuple< Ts... > const &a, common_tuple< Us... > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) EqualityComparable< Ts, Us >()... >::value), int >::type = 0>
bool | operator!= (std::tuple< Ts... > const &a, common_tuple< Us... > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) EqualityComparable< Ts, Us >()... >::value), int >::type = 0>
bool | operator!= (common_tuple< Ts... > const &a, std::tuple< Us... > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(EqualityComparable< F1, F2 >()&&EqualityComparable< S1, S2 >()), int >::type = 0>
bool | operator!= (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(EqualityComparable< F1, F2 >()&&EqualityComparable< S1, S2 >()), int >::type = 0>
bool | operator!= (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(EqualityComparable< F1, F2 >()&&EqualityComparable< S1, S2 >()), int >::type = 0>
bool | operator!= (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b)
template<typename I , typename S , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(Sentinel< S, I >()), int >::type = 0>
bool | operator!= (move_iterator< S > const &i, move_sentinel< S > const &s)
template<typename I , typename S , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(Sentinel< S, I >()), int >::type = 0>
bool | operator!= (move_sentinel< S > const &s, move_iterator< S > const &i)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0>
bool | operator< (common_tuple< Ts... > const &a, std::tuple< Us... > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0>
bool | operator< (common_tuple< Ts... > const &a, common_tuple< Us... > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0>
bool | operator< (std::tuple< Ts... > const &a, common_tuple< Us... > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0>
bool | operator< (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0>
bool | operator< (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0>
bool | operator< (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0>
bool | operator<= (common_tuple< Ts... > const &a, common_tuple< Us... > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0>
bool | operator<= (std::tuple< Ts... > const &a, common_tuple< Us... > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0>
bool | operator<= (common_tuple< Ts... > const &a, std::tuple< Us... > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0>
bool | operator<= (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0>
bool | operator<= (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0>
bool | operator<= (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) EqualityComparable< Ts, Us >()... >::value), int >::type = 0>
bool | operator== (common_tuple< Ts... > const &a, std::tuple< Us... > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) EqualityComparable< Ts, Us >()... >::value), int >::type = 0>
bool | operator== (std::tuple< Ts... > const &a, common_tuple< Us... > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) EqualityComparable< Ts, Us >()... >::value), int >::type = 0>
bool | operator== (common_tuple< Ts... > const &a, common_tuple< Us... > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(EqualityComparable< F1, F2 >()&&EqualityComparable< S1, S2 >()), int >::type = 0>
bool | operator== (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(EqualityComparable< F1, F2 >()&&EqualityComparable< S1, S2 >()), int >::type = 0>
bool | operator== (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(EqualityComparable< F1, F2 >()&&EqualityComparable< S1, S2 >()), int >::type = 0>
bool | operator== (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
template<typename I , typename S , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(Sentinel< S, I >()), int >::type = 0>
bool | operator== (move_iterator< I > const &i, move_sentinel< S > const &s)
template<typename I , typename S , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(Sentinel< S, I >()), int >::type = 0>
bool | operator== (move_sentinel< S > const &s, move_iterator< S > const &i)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0>
bool | operator> (common_tuple< Ts... > const &a, std::tuple< Us... > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0>
bool | operator> (std::tuple< Ts... > const &a, common_tuple< Us... > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0>
bool | operator> (common_tuple< Ts... > const &a, common_tuple< Us... > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0>
bool | operator> (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0>
bool | operator> (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0>
bool | operator> (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0>
bool | operator>= (std::tuple< Ts... > const &a, common_tuple< Us... > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0>
bool | operator>= (common_tuple< Ts... > const &a, std::tuple< Us... > const &b)
template<typename... Ts, typename... Us, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(meta::and_c<(bool) TotallyOrdered< Ts, Us >()... >::value), int >::type = 0>
bool | operator>= (common_tuple< Ts... > const &a, common_tuple< Us... > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0>
bool | operator>= (common_pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0>
bool | operator>= (common_pair< F1, S1 > const &a, std::pair< F2, S2 > const &b)
template<typename F1 , typename S1 , typename F2 , typename S2 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(TotallyOrdered< F1, F2 >()&&TotallyOrdered< S1, S2 >()), int >::type = 0>
bool | operator>= (std::pair< F1, S1 > const &a, common_pair< F2, S2 > const &b)
template<typename Arg , typename Pipe , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(!is_pipeable< Arg >()&&is_pipeable< Pipe >()), int >::type = 0>
auto | operator| (Arg &&arg, Pipe pipe) -> decltype(pipeable_access::impl< Pipe >::pipe(std::forward< Arg >(arg), pipe))
template<typename Pipe0 , typename Pipe1 , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(is_pipeable< Pipe0 >()&&is_pipeable< Pipe1 >()), int >::type = 0>
auto | operator| (Pipe0 pipe0, Pipe1 pipe1) -> decltype(make_pipeable(detail::composed_pipe< Pipe0, Pipe1 >
template<template< typename... > class ContT>
detail::to_container_fn< meta::quote< ContT > > | to_ ()
| For initializing a container of the specified type with the elements of an Range.
template<template< typename... > class ContT, typename Rng , typename Cont = meta::invoke<meta::quote<ContT>, range_value_t<Rng>>, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(Range< Rng >()&&detail::ConvertibleToContainer< Rng, Cont >()), int >::type = 0>
Cont | to_ (Rng &&rng)
template<template< typename... > class ContT, typename T , typename Cont = meta::invoke<meta::quote<ContT>, T>, int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(detail::ConvertibleToContainer< std::initializer_list< T >, Cont >()), int >::type = 0>
Cont | to_ (std::initializer_list< T > list)
template<typename Cont >
detail::to_container_fn< meta::id< Cont > > | to_ ()
template<typename Cont , typename Rng , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(Range< Rng >()&&detail::ConvertibleToContainer< Rng, Cont >()), int >::type = 0>
Cont | to_ (Rng &&rng)
template<typename Cont , typename T , int _concept_requires___LINE__ = 42, typename std::enable_if< (_concept_requires___LINE__==43)||(detail::ConvertibleToContainer< std::initializer_list< T >, Cont >()), int >::type = 0>
Cont | to_ (std::initializer_list< T > list)

## Detailed Description

Protect a callable so that it can be safely used in a bind expression without accidentally becoming a "nested" bind.

See also
  `is_heap_fn`
  `push_heap_fn`
  `pop_heap_fn`
  `make_heap_fn`
  `sort_heap_fn`
  `next_permutation_fn`
  `prev_permutation_fn`
  `set_union_fn`
  `set_intersection_fn`
  `set_difference_fn`
  `set_symmetric_difference_fn`

Returns
  The result of an unqualified call to the `end` free function
  The result of an unqualified call to the `rbegin` free function
  The result of an unqualified call to the `rend` free function
  The result of an unqualified call to the `begin` free function with a const-qualified argument.
  The result of an unqualified call to the `end` free function with a const-qualified argument.
  The result of an unqualified call to the `rbegin` free function with a const-qualified argument.
  The result of an unqualified call to the `rend` free function with a const-qualified argument.
  `begin(rng)` if `rng` is an lvalue; otherwise, it returns `begin(rng)` wrapped in `ranges::dangling`.
  `end(rng)` if `rng` is an lvalue; otherwise, it returns `end(rng)` wrapped in `ranges::dangling`.

See also
  `distance_fn`
  `distance_compare_fn`
  `make_common_pair_fn`

Returns
  the result of replacing all `ranges::dangling<T>` objects with `ranges::dangling<void>`, introspecting `std::pair` and `std::tuple` objects recursively.

See also
  `not_fn`
  `compose_fn`
  `overload_fn`
  `indirect_fn`
  `on_fn`
  `make_pipeable_fn`
  `ref_fn`
  `rref_fn`
  `unwrap_reference_fn`
  `protect_fn`
  `next_fn`
  `prev_fn`
  `iter_enumerate_fn`
  `iter_distance_fn`
  `iter_distance_compare_fn`
  `iter_size_fn`
  `iter_swap_fn`
  `iter_move_fn`
  `back_inserter_fn`
  `front_inserter_fn`
  `move_into_fn`
  `tuple_transform_fn`
  `tuple_foldl_fn`
  `tuple_for_each_fn`
  `make_tuple_fn`

## Function Documentation

template<typename T >

meta::if_c< std::is_reference< T >)||Copyable< T >), T > ranges::v3::any_cast | ( | any & | x | ) |

Exceptions

  bad_any_cast |

template<typename T >

meta::if_c< std::is_reference< T >)||Copyable< T >), T > ranges::v3::any_cast | ( | any const & | x | ) |

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 >

meta::if_c< std::is_reference< T >)||Copyable< T >), T > ranges::v3::any_cast | ( | any && | x | ) |

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 >

T * ranges::v3::any_cast | ( | any * | p | ) |
| noexcept

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 >

T const * ranges::v3::any_cast | ( | any const * | p | ) |
| noexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename Cont >

detail::to_container_fn<meta::id<Cont> > ranges::v3::to_ | ( |  | ) |

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.