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 )