Namespaces
namespace	erase_ns

namespace	ring

namespace	string

namespace	vector

namespace	view

Classes
class	AdjacentTransformView

class	AdjacentView

struct	AdvanceFunction

struct	Allocation

struct	AllocationResult

class	AsConstView

class	AsRValueView

struct	BeginFunction

class	CacheLastView

class	CartesianProductView

struct	CBeginFunction

struct	CDataFunction

struct	CEndFunction

class	ChunkByView

class	ChunkView

class	ChunkView< View >

class	CommonIterator

class	CommonView

class	ConcatView

class	ConstantPathInterface

class	ConstantRingInterface

class	ConstantVectorInterface

class	ConstIteratorImpl

class	CountedIterator

struct	CRBeginFunction

struct	CREndFunction

class	CycleView

struct	Dangling

struct	DataFunction

struct	DefaultHasher

struct	DefaultIntrusiveForwardListTag

struct	DefaultIntrusiveHashSetTag

struct	DefaultIntrusiveListTag

struct	DefaultIntrusiveTreeSetTag

struct	DefaultSentinel

class	DropView

class	DropWhileView

class	ElementsView

struct	EmptyFunction

class	EmptyView

struct	EnableBorrowedContainer

struct	EnableViewFunction

struct	EndFunction

class	EnumerateView

class	ErasedString

struct	FailAllocator

struct	FallibleAllocator

class	FilterView

class	FixedString

struct	HashNode

class	HashNodeIterator

struct	InfallibleAllocator

struct	InFoundResult

struct	InFunResult

struct	InInOutResult

struct	InInResult

struct	InOutOutResult

struct	InOutResult

class	IntrusiveForwardList

class	IntrusiveForwardListNode

struct	IntrusiveForwardListTag

class	IntrusiveHashMultiSet

class	IntrusiveHashSet

struct	IntrusiveHashSetTag

class	IntrusiveList

class	IntrusiveListNode

struct	IntrusiveListTag

class	IntrusiveSetInterface

struct	IntrusiveTagBase

class	IntrusiveTreeMultiSet

class	IntrusiveTreeSet

struct	IntrusiveTreeSetTag

struct	InValueResult

class	IotaView

struct	IteratorBase

struct	IteratorCategoryFunction

class	IteratorExtension

struct	IteratorSSizeTypeFunction

struct	IteratorValueFunction

class	JoinView

class	JoinWithView

class	LinkedList

class	MapInterface

struct	MinMaxResult

class	MoveIterator

class	MoveSentinel

class	MutableRingInterface

class	MutableVectorInterface

struct	NextFunction

struct	NoCapacityError

class	NodeHashMap

class	NodeHashMultiMap

class	NodeHashMultiSet

class	NodeHashSet

class	NodeHashTable
	Node based (closed addressing) hash table. More...

struct	OutValueResult

struct	OwningHashNode

struct	OwningHashNodeTag

class	OwningNodeHashTable

class	OwningRBTree

struct	OwningRBTreeNode

struct	OwningRBTreeTag

class	OwningView

class	PathImpl

class	PathIterator

class	PathViewImpl

struct	PrevFunction

class	PriorityQueue

class	Queue

struct	RBeginFunction

class	RBTree
	General implementation of the Red-Black self-balancing binary tree. More...

class	RBTreeIterator

struct	RBTreeNode

struct	ReconstructFunction

class	RefView

struct	REndFunction

class	RepeatView

class	ReverseIterator

class	ReverseView

class	Ring

class	RingIterator

class	SentinelBase

class	SentinelExtension

class	SetInterface

class	SingleView

struct	SizeFunction

class	SlideView

class	SplitView

struct	SSizeFunction

class	Stack

class	StaticRing

class	StaticVector

class	StrideView

class	TakeView

class	TakeWhileView

class	TransformView

class	TreeMap

class	TreeMultiMap

class	TreeMultiSet

class	TreeSet

struct	UnreachableSentinel

class	Vector

class	View

class	ViewInterface

class	ZipTransformView

class	ZipView

class	ZStringImpl

Typedefs
template<typename In, typename Out>
using	MoveResult = InOutResult<In, Out>

template<typename In, typename Out>
using	MoveBackwardResult = InOutResult<In, Out>

template<typename In, typename Out>
using	UninitializedRelocateResult = container::InOutResult<In, Out>

template<typename In, typename Out>
using	UninitializedRelocateBackwardsResult = container::InOutResult<In, Out>

template<typename T>
using	StdAllocator = std::allocator<T>

template<typename Tag>
using	IntrusiveHashSetNode = HashNode<Tag>

template<typename Tag = DefaultIntrusiveTreeSetTag>
using	IntrusiveTreeSetNode = RBTreeNode<Tag>

using	Path = PathImpl<TransparentString>

using	Utf8Path = PathImpl<String>

using	PathView = PathViewImpl<string::TransparentEncoding>

using	Utf8PathView = PathViewImpl<string::Utf8Encoding>

using	String = string::StringImpl<string::Utf8Encoding>

using	TransparentString = string::StringImpl<string::TransparentEncoding>

using	StringView = string::StringViewImpl<string::Utf8Encoding>

using	TransparentStringView = string::StringViewImpl<string::TransparentEncoding>

using	ZCString = ZStringImpl<char const>

using	ZCUString = ZStringImpl<unsigned char const>

using	ZCWString = ZStringImpl<wchar_t const>

using	ZString = ZStringImpl<char>

using	ZUString = ZStringImpl<unsigned char>

using	ZWString = ZStringImpl<wchar_t>

using	ZC8CString = ZStringImpl<c8 const>

using	ZC8String = ZStringImpl<c8>

using	ZC16CString = ZStringImpl<c16 const>

using	ZC16String = ZStringImpl<c16>

using	ZC32CString = ZStringImpl<c32 const>

using	ZC32String = ZStringImpl<c32>

template<typename Con>
using	KeysView = ElementsView<Con, 0>

template<typename Con>
using	ValuesView = ElementsView<Con, 1>

Functions
template<typename Out, concepts::InputContainer Con, typename... Args> requires (!concepts::View<Out> && concepts::Expected<meta::ContainerValue<Con>>)
constexpr auto	sequence_to (Con &&container, Args &&... args)

template<template< typename... > typename Template, concepts::InputContainer Con, typename... Args, typename UnwrappedContainer = EmptyView<meta::ExpectedValue<meta::ContainerValue<Con>>>> requires (concepts::CreateDeducible<Template, UnwrappedContainer, Args...> \|\| concepts::CreateDeducible<Template, FromContainer, UnwrappedContainer, Args...>)
constexpr auto	sequence_to (Con &&container, Args &&... args)

template<typename Out, typename... Args> requires (!concepts::View<Out>)
constexpr auto	sequence_to (Args &&... args)

template<template< typename... > typename Template, typename... Args>
constexpr auto	sequence_to (Args &&... args)

template<typename Out, concepts::InputContainer Con, typename... Args> requires (!concepts::View<Out>)
constexpr auto	to (Con &&container, Args &&... args)

template<template< typename... > typename Template, concepts::InputContainer Con, typename... Args> requires (concepts::CreateDeducible<Template, Con, Args...> \|\| concepts::CreateDeducible<Template, FromContainer, Con, Args...>)
constexpr auto	to (Con &&container, Args &&... args)

template<typename Out, typename... Args> requires (!concepts::View<Out>)
constexpr auto	to (Args &&... args)

template<template< typename... > typename Template, typename... Args>
constexpr auto	to (Args &&... args)

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>> requires (meta::TupleSize<T> == 2)
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMap >, Con &&) -> NodeHashMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq> requires (meta::TupleSize<T> == 2)
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMap >, Con &&, Eq) -> NodeHashMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq >

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq, typename Hasher> requires (meta::TupleSize<T> == 2)
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMap >, Con &&, Eq, Hasher) -> NodeHashMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq, Hasher >

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>> requires (meta::TupleSize<T> == 2)
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMultiMap >, Con &&) -> NodeHashMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq> requires (meta::TupleSize<T> == 2)
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMultiMap >, Con &&, Eq) -> NodeHashMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq >

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq, typename Hasher> requires (meta::TupleSize<T> == 2)
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMultiMap >, Con &&, Eq, Hasher) -> NodeHashMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq, Hasher >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMultiSet >, Con &&) -> NodeHashMultiSet< T >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMultiSet >, Con &&, Eq) -> NodeHashMultiSet< T, Eq >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq, typename Hasher>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMultiSet >, Con &&, Eq, Hasher) -> NodeHashMultiSet< T, Eq, Hasher >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashSet >, Con &&) -> NodeHashSet< T >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashSet >, Con &&, Eq) -> NodeHashSet< T, Eq >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq, typename Hasher>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashSet >, Con &&, Eq, Hasher) -> NodeHashSet< T, Eq, Hasher >

template<typename Iter, concepts::EqualityComparableWith< Iter > U>
constexpr auto	operator== (MoveIterator< Iter > const &a, MoveIterator< U > const &b) -> bool

template<typename Iter, concepts::ThreeWayComparableWith< Iter > U>
constexpr auto	operator<=> (MoveIterator< Iter > const &a, MoveIterator< U > const &b)

template<typename Iter, typename U>
constexpr auto	operator- (MoveIterator< Iter > const &a, MoveIterator< U > const &b) -> decltype(a.base() - b.base())

template<concepts::InputIterator Iter>
constexpr auto	make_move_iterator (Iter iterator)

template<typename Iter, concepts::EqualityComparableWith< Iter > U>
constexpr auto	operator== (ReverseIterator< Iter > const &a, ReverseIterator< U > const &b) -> bool

template<typename Iter, concepts::ThreeWayComparableWith< Iter > U>
constexpr auto	operator<=> (ReverseIterator< Iter > const &a, ReverseIterator< U > const &b)

template<typename Iter, typename U>
constexpr auto	operator- (ReverseIterator< Iter > const &a, ReverseIterator< U > const &b) -> decltype(b.base() - a.base())

template<concepts::BidirectionalIterator Iter>
constexpr auto	make_reverse_iterator (Iter iter)

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< LinkedList >, Con &&) -> LinkedList< T >

template<concepts::Container Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp> requires (detail::PriorityQueueCompatible<Con, T>)
	PriorityQueue (Comp, Con) -> PriorityQueue< T, Con, Comp >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< PriorityQueue >, Con &&) -> PriorityQueue< T >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< PriorityQueue >, Con &&, Comp) -> PriorityQueue< T, container::Vector< T >, Comp >

template<concepts::Container Con, typename T = meta::ContainerValue<Con>> requires (detail::QueueCompatible<Con, T>)
	Queue (Con) -> Queue< T, Con >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< Queue >, Con &&) -> Queue< T >

template<concepts::Container Con, typename T = meta::ContainerValue<Con>> requires (detail::StackCompatible<Con, T>)
	Stack (Con) -> Stack< T, Con >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< Stack >, Con &&) -> Stack< T >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< Ring >, Con &&) -> Ring< T >

template<types::size_t size>
	FixedString (char const (&)[size]) -> FixedString< size - 1 >

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>> requires (meta::TupleSize<T> == 2)
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeMap >, Con &&) -> TreeMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp> requires (meta::TupleSize<T> == 2)
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeMap >, Con &&, Comp) -> TreeMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Comp >

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>> requires (meta::TupleSize<T> == 2)
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeMultiMap >, Con &&) -> TreeMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp> requires (meta::TupleSize<T> == 2)
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeMultiMap >, Con &&, Comp) -> TreeMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Comp >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeMultiSet >, Con &&) -> TreeMultiSet< T >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeMultiSet >, Con &&, Comp) -> TreeMultiSet< T, Comp >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeSet >, Con &&) -> TreeSet< T >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeSet >, Con &&, Comp) -> TreeSet< T, Comp >

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto	tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< Vector >, Con &&) -> Vector< T >

template<typename Con>
	AsConstView (Con &&) -> AsConstView< meta::AsView< Con > >

template<typename Con>
	AsRValueView (Con &&) -> AsRValueView< meta::AsView< Con > >

template<typename... Cons>
	CartesianProductView (Cons &&...) -> CartesianProductView< meta::AsView< Cons >... >

template<typename Con, typename Pred>
	ChunkByView (Con &&, Pred) -> ChunkByView< meta::AsView< Con >, Pred >

template<typename Con>
	ChunkView (Con &&, meta::ContainerSSizeType< Con >) -> ChunkView< meta::AsView< Con > >

template<typename Con>
	CommonView (Con &&) -> CommonView< meta::AsView< Con > >

template<typename... Cons>
	ConcatView (Cons &&...) -> ConcatView< meta::AsView< Cons >... >

template<typename Con>
	CycleView (Con &&) -> CycleView< meta::AsView< Con > >

template<typename Con>
	DropView (Con &&, meta::ContainerSSizeType< Con >) -> DropView< meta::AsView< Con > >

template<typename Con, typename Pred>
	DropWhileView (Con &&, Pred) -> DropWhileView< meta::AsView< Con >, Pred >

template<typename Con>
	EnumerateView (Con &&) -> EnumerateView< meta::AsView< Con > >

template<typename Con, typename Pred>
	FilterView (Con &&, Pred) -> FilterView< meta::AsView< Con >, Pred >

template<typename T, typename Bound> requires (!concepts::Integer<T> \|\| !concepts::Integer<Bound> \|\| concepts::SignedInteger<T> == concepts::SignedInteger<Bound>)
	IotaView (T, Bound) -> IotaView< T, Bound >

template<typename Con>
	JoinView (Con &&) -> JoinView< meta::AsView< Con > >

template<typename Con, typename Pattern>
	JoinWithView (Con &&, Pattern &&) -> JoinWithView< meta::AsView< Con >, meta::AsView< Pattern > >

template<concepts::InputContainer Con>
	JoinWithView (Con &&, meta::ContainerValue< meta::ContainerReference< Con > >) -> JoinWithView< meta::AsView< Con >, SingleView< meta::ContainerValue< meta::ContainerReference< Con > > > >

template<typename Cont>
	RefView (Cont &) -> RefView< Cont >

template<typename T, typename Bound>
	RepeatView (T, Bound) -> RepeatView< T, Bound >

template<typename Con>
	ReverseView (Con &&) -> ReverseView< meta::AsView< Con > >

template<typename T>
	SingleView (T) -> SingleView< T >

template<typename Con>
	SlideView (Con &&, meta::ContainerSSizeType< Con >) -> SlideView< meta::AsView< Con > >

template<typename Con, typename Pattern>
	SplitView (Con &&, Pattern &&) -> SplitView< meta::AsView< Con >, meta::AsView< Pattern > >

template<concepts::InputContainer Con>
	SplitView (Con &&, meta::ContainerValue< Con >) -> SplitView< meta::AsView< Con >, SingleView< meta::ContainerValue< Con > > >

template<typename Con>
	StrideView (Con &&, meta::ContainerSSizeType< Con >) -> StrideView< meta::AsView< Con > >

template<typename Con>
	TakeView (Con &&, meta::ContainerSSizeType< Con >) -> TakeView< meta::AsView< Con > >

template<typename Con, typename Pred>
	TakeWhileView (Con &&, Pred) -> TakeWhileView< meta::AsView< Con >, Pred >

template<typename Con, typename F>
	TransformView (Con &&, F) -> TransformView< meta::AsView< Con >, F >

template<concepts::Iterator Iter, concepts::SentinelFor< Iter > Sent>
	View (Iter, Sent) -> View< Iter, Sent >

template<concepts::Iterator Iter, concepts::SentinelFor< Iter > Sent>
	View (Iter, Sent, meta::IteratorSizeType< Iter >) -> View< Iter, Sent, true >

template<concepts::BorrowedContainer Cont>
	View (Cont &&) -> View< meta::ContainerIterator< Cont >, meta::ContainerSentinel< Cont >, concepts::SizedContainer< Cont >\|\|concepts::SizedSentinelFor< meta::ContainerSentinel< Cont >, meta::ContainerIterator< Cont > > >

template<concepts::BorrowedContainer Cont>
	View (Cont &&, meta::ContainerSizeType< Cont >) -> View< meta::ContainerIterator< Cont >, meta::ContainerSentinel< Cont >, true >

template<class F, class... Cons>
	ZipTransformView (F, Cons &&...) -> ZipTransformView< F, meta::AsView< Cons >... >

template<typename... Cons>
	ZipView (Cons &&...) -> ZipView< meta::AsView< Cons >... >

Variables
constexpr auto	sequence = function::curry_back(detail::SequenceFunction {}, meta::c_<2ZU>)

constexpr auto	adjacent_find = detail::AdjacentFindFunction {}

constexpr auto	all_of = detail::AllOfFunction {}

constexpr auto	any_of = detail::AnyOfFunction {}

constexpr auto	binary_search = detail::BinarySearchFunction {}

constexpr auto	compare = detail::CompareFunction {}

constexpr auto	contains = detail::ContainsFunction {}

constexpr auto	contains_subrange = detail::ContainsSubrangeFunction {}

constexpr auto	copy = detail::CopyFunction {}

constexpr auto	copy_backward = detail::CopyBackwardFunction {}

constexpr auto	copy_if = detail::CopyIfFunction {}

constexpr auto	copy_n = detail::CopyNFunction {}

constexpr auto	count = detail::CountFunction {}

constexpr auto	count_if = detail::CountIfFunction {}

constexpr auto	destroy = detail::DestroyFunction {}

constexpr auto	destroy_n = detail::DestroyNFunction {}

constexpr auto	ends_with = detail::EndsWithFunction {}

constexpr auto	equal = detail::EqualFunction {}

constexpr auto	equal_range = detail::EqualRangeFunction {}

constexpr auto	fill = detail::FillFunction {}

constexpr auto	fill_n = detail::FillNFunction {}

constexpr auto	find = detail::FindFunction {}

constexpr auto	find_end = detail::FindEndFunction {}

constexpr auto	find_first_not_of = detail::FindFirstNotOfFunction {}

constexpr auto	find_first_of = detail::FindFirstOfFunction {}

constexpr auto	find_if = detail::FindIfFunction {}

constexpr auto	find_if_not = detail::FindIfNotFunction {}

constexpr auto	find_last = detail::FindLastFunction {}

constexpr auto	find_last_if = detail::FindLastIfFunction {}

constexpr auto	find_last_if_not = detail::FindLastIfNotFunction {}

constexpr auto	find_last_not_of = detail::FindLastNotOfFunction {}

constexpr auto	find_last_of = detail::FindLastOfFunction {}

constexpr auto	fold_left = function::curry_back(detail::FoldLeftFunction {}, meta::c_<3ZU>)

constexpr auto	fold_left_first = function::curry_back(detail::FoldLeftFirstFunction {}, meta::c_<2ZU>)

constexpr auto	fold_left_first_with_iter = detail::FoldLeftFirstWithIterFunction {}

constexpr auto	fold_left_with_iter = detail::FoldLeftWithIterFunction {}

constexpr auto	fold_right = detail::FoldRightFunction {}

constexpr auto	fold_right_last = detail::FoldRightLastFunction {}

constexpr auto	for_each = detail::ForEachFunction {}

constexpr auto	for_each_n = detail::ForEachNFunction {}

constexpr auto	generate = detail::GenerateFunction {}

constexpr auto	generate_n = detail::GenerateNFunction {}

constexpr auto	includes = detail::IncludesFunction {}

constexpr auto	iota = detail::IotaFunction {}

constexpr auto	is_heap = detail::IsHeapFunction {}

constexpr auto	is_heap_until = detail::IsHeapUntilFunction {}

constexpr auto	is_partitioned = detail::IsPartitionedFunction {}

constexpr auto	is_permutation = detail::IsPermutationFunction {}

constexpr auto	is_sorted = detail::IsSortedFunction {}

constexpr auto	is_sorted_until = detail::IsSortedUntilFunction {}

constexpr auto	lower_bound = detail::LowerBoundFunction {}

constexpr auto	make_heap = detail::MakeHeapFunction {}

constexpr auto	max = detail::MaxFunction {}

constexpr auto	max_element = detail::MaxElementFunction {}

constexpr auto	merge = detail::MergeFunction {}

constexpr auto	min = detail::MinFunction {}

constexpr auto	min_element = detail::MinElementFunction {}

constexpr auto	minmax = detail::MinMaxFunction {}

constexpr auto	minmax_element = detail::MinMaxElementFunction {}

constexpr auto	mismatch = detail::MismatchFunction {}

constexpr auto	move = detail::MoveFunction {}

constexpr auto	move_backward = detail::MoveBackwardFunction {}

constexpr auto	next_permutation = detail::NextPermutationFunction {}

constexpr auto	none_of = detail::NoneOfFunction {}

constexpr auto	partition = detail::PartitionFunction {}

constexpr auto	partition_copy = detail::PartitionCopyFunction {}

constexpr auto	partition_point = detail::PartitionPointFunction {}

constexpr auto	pop_heap = detail::PopHeapFunction {}

constexpr auto	prev_permutation = detail::PrevPermutationFunction {}

constexpr auto	product = detail::ProductFunction {}

constexpr auto	push_heap = detail::PushHeapFunction {}

constexpr auto	remove = detail::RemoveFunction {}

constexpr auto	remove_copy = detail::RemoveCopyFunction {}

constexpr auto	remove_copy_if = detail::RemoveCopyIfFunction {}

constexpr auto	remove_if = detail::RemoveIfFunction {}

constexpr auto	replace = detail::ReplaceFunction {}

constexpr auto	replace_copy = detail::ReplaceCopyFunction {}

constexpr auto	replace_copy_if = detail::ReplaceCopyIfFunction {}

constexpr auto	replace_if = detail::ReplaceIfFunction {}

constexpr auto	reverse = detail::ReverseFunction {}

constexpr auto	reverse_copy = detail::ReverseCopyFunction {}

constexpr auto	rotate = detail::RotateFunction {}

constexpr auto	rotate_copy = detail::RotateCopyFunction {}

constexpr auto	sample = detail::SampleFunction {}

constexpr auto	search = detail::SearchFunction {}

constexpr auto	search_n = detail::SearchNFunction {}

constexpr auto	set_difference = detail::SetDifferenceFunction {}

constexpr auto	set_intersection = detail::SetIntersectionFunction {}

constexpr auto	set_symmetric_difference = detail::SetSymmetricDifferenceFunction {}

constexpr auto	set_union = detail::SetUnionFunction {}

constexpr auto	shift_left = detail::ShiftLeftFunction {}

constexpr auto	shift_right = detail::ShiftRightFunction {}

constexpr auto	shuffle = detail::ShuffleFunction {}

constexpr auto	sort = detail::SortFunction {}

constexpr auto	sort_heap = detail::SortHeapFunction {}

constexpr auto	stable_partition = detail::StablePartitionFunction {}

constexpr auto	starts_with = detail::StartsWithFunction {}

constexpr auto	sum = detail::SumFunction {}

constexpr auto	swap_ranges = detail::SwapRanges {}

constexpr auto	transform = detail::TransformFunction {}

constexpr auto	uninitialized_copy = detail::UninitializedCopyFunction {}

constexpr auto	uninitialized_copy_n = detail::UninitializedCopyNFunction {}

constexpr auto	uninitialized_default_construct = detail::UninitializedDefaultConstructFunction {}

constexpr auto	uninitialized_default_construct_n = detail::UninitializedDefaultConstructNFunction {}

constexpr auto	uninitialized_fill = detail::UninitializedFillFunction {}

constexpr auto	uninitialized_fill_n = detail::UninitializedFillNFunction {}

constexpr auto	uninitialized_move = detail::UninitializedMoveFunction {}

constexpr auto	uninitialized_move_n = detail::UninitializedMoveNFunction {}

constexpr auto	uninitialized_relocate = detail::UninitializedRelocateFunction {}

constexpr auto	uninitialized_relocate_backwards = detail::UninitializedRelocateBackwardsFunction {}

constexpr auto	uninitialized_value_construct = detail::UninitializedValueConstructFunction {}

constexpr auto	uninitialized_value_construct_n = detail::UninitializedValueConstructNFunction {}

constexpr auto	unique = detail::UniqueFunction {}

constexpr auto	unique_copy = detail::UniqueCopyFunction {}

constexpr auto	upper_bound = detail::UpperBoundFunction {}

constexpr auto	allocate = detail::AllocateFunction {}

template<typename T>
constexpr auto	allocate_many = detail::AllocateManyFunction<T> {}

template<typename T>
constexpr auto	allocate_one = detail::AllocateOneFunction<T> {}

constexpr auto	deallocate = detail::DeallocateFunction {}

template<typename T>
constexpr auto	deallocate_many = detail::DeallocateManyFunction<T> {}

template<typename T>
constexpr auto	deallocate_one = detail::DeallocateOneFunction<T> {}

constexpr auto	fail_allocator = FailAllocator {}

constexpr auto	hash = detail::HashFunction {}

constexpr auto	hash_same = detail::HashSameFunction {}

constexpr auto	hash_write = detail::HashWriteFunction {}

constexpr auto	front = detail::FrontFunction {}

constexpr auto	back = detail::BackFunction {}

constexpr auto	at = di::curry_back(detail::AtFunction {}, c_<2ZU>)

constexpr auto	front_unchecked = detail::FrontUncheckedFunction {}

constexpr auto	back_unchecked = detail::BackUncheckedFunction {}

constexpr auto	at_unchecked = di::curry_back(detail::AtUncheckedFunction {}, c_<2ZU>)

constexpr auto	begin = BeginFunction {}

constexpr auto	cbegin = CBeginFunction {}

constexpr auto	cdata = CDataFunction {}

constexpr auto	cend = CEndFunction {}

constexpr auto	crbegin = CRBeginFunction {}

constexpr auto	crend = CREndFunction {}

constexpr auto	data = DataFunction {}

constexpr auto	empty = EmptyFunction {}

constexpr struct di::container::EnableBorrowedContainer	enable_borrowed_container

constexpr struct di::container::EnableViewFunction	enable_view

constexpr auto	end = EndFunction {}

constexpr auto	erase = erase_ns::EraseFunction {}

constexpr auto	erase_if = erase_ns::EraseIfFunction {}

constexpr auto	rbegin = RBeginFunction {}

constexpr auto	reconstruct = ReconstructFunction {}

constexpr auto	rend = REndFunction {}

constexpr auto	size = SizeFunction {}

constexpr auto	ssize = SSizeFunction {}

constexpr auto	advance = AdvanceFunction {}

constexpr auto	default_sentinel = DefaultSentinel {}

constexpr auto	distance = detail::DistanceFunction {}

constexpr struct di::container::IteratorCategoryFunction	iterator_category

constexpr auto	iterator_move = detail::IteratorMoveFunction {}

constexpr struct di::container::IteratorSSizeTypeFunction	iterator_ssize_type

constexpr auto	iterator_swap = detail::IteratorSwapFunction {}

constexpr struct di::container::IteratorValueFunction	iterator_value

constexpr auto	next = NextFunction {}

constexpr auto	prev = PrevFunction {}

constexpr auto	unreachable_sentinel = UnreachableSentinel {}

constexpr auto	into_erased_string = detail::IntoErasedStringFunction {}

constexpr auto	fixed_string_concat = detail::FixedStringConcat {}

template<FixedString literal>
constexpr auto	fixed_string_to_utf8_string_view = detail::FixedStringToUtf8StringViewFunction<literal> {}

Typedef Documentation

◆ IntrusiveHashSetNode

template<typename Tag>

using di::container::IntrusiveHashSetNode = HashNode<Tag>

◆ IntrusiveTreeSetNode

template<typename Tag = DefaultIntrusiveTreeSetTag>

using di::container::IntrusiveTreeSetNode = RBTreeNode<Tag>

◆ KeysView

template<typename Con>

using di::container::KeysView = ElementsView<Con, 0>

◆ MoveBackwardResult

template<typename In, typename Out>

using di::container::MoveBackwardResult = InOutResult<In, Out>

◆ MoveResult

template<typename In, typename Out>

using di::container::MoveResult = InOutResult<In, Out>

◆ Path

using di::container::Path = PathImpl<TransparentString>

◆ PathView

using di::container::PathView = PathViewImpl<string::TransparentEncoding>

◆ StdAllocator

template<typename T>

using di::container::StdAllocator = std::allocator<T>

◆ String

using di::container::String = string::StringImpl<string::Utf8Encoding>

◆ StringView

using di::container::StringView = string::StringViewImpl<string::Utf8Encoding>

◆ TransparentString

using di::container::TransparentString = string::StringImpl<string::TransparentEncoding>

◆ TransparentStringView

using di::container::TransparentStringView = string::StringViewImpl<string::TransparentEncoding>

◆ UninitializedRelocateBackwardsResult

template<typename In, typename Out>

using di::container::UninitializedRelocateBackwardsResult = container::InOutResult<In, Out>

◆ UninitializedRelocateResult

template<typename In, typename Out>

using di::container::UninitializedRelocateResult = container::InOutResult<In, Out>

◆ Utf8Path

using di::container::Utf8Path = PathImpl<String>

◆ Utf8PathView

using di::container::Utf8PathView = PathViewImpl<string::Utf8Encoding>

◆ ValuesView

template<typename Con>

using di::container::ValuesView = ElementsView<Con, 1>

◆ ZC16CString

using di::container::ZC16CString = ZStringImpl<c16 const>

◆ ZC16String

using di::container::ZC16String = ZStringImpl<c16>

◆ ZC32CString

using di::container::ZC32CString = ZStringImpl<c32 const>

◆ ZC32String

using di::container::ZC32String = ZStringImpl<c32>

◆ ZC8CString

using di::container::ZC8CString = ZStringImpl<c8 const>

◆ ZC8String

using di::container::ZC8String = ZStringImpl<c8>

◆ ZCString

using di::container::ZCString = ZStringImpl<char const>

◆ ZCUString

using di::container::ZCUString = ZStringImpl<unsigned char const>

◆ ZCWString

using di::container::ZCWString = ZStringImpl<wchar_t const>

◆ ZString

using di::container::ZString = ZStringImpl<char>

◆ ZUString

using di::container::ZUString = ZStringImpl<unsigned char>

◆ ZWString

using di::container::ZWString = ZStringImpl<wchar_t>

Function Documentation

◆ AsConstView()

template<typename Con>

di::container::AsConstView ( Con && ) -> AsConstView< meta::AsView< Con > >

◆ AsRValueView()

template<typename Con>

di::container::AsRValueView ( Con && ) -> AsRValueView< meta::AsView< Con > >

◆ CartesianProductView()

template<typename... Cons>

di::container::CartesianProductView ( Cons && ... ) -> CartesianProductView< meta::AsView< Cons >... >

◆ ChunkByView()

template<typename Con, typename Pred>

di::container::ChunkByView	(	Con &&	,
		Pred	) -> ChunkByView< meta::AsView< Con >, Pred >

◆ ChunkView()

template<typename Con>

di::container::ChunkView	(	Con &&	,
		meta::ContainerSSizeType< Con >	) -> ChunkView< meta::AsView< Con > >

◆ CommonView()

template<typename Con>

di::container::CommonView ( Con && ) -> CommonView< meta::AsView< Con > >

◆ ConcatView()

template<typename... Cons>

di::container::ConcatView ( Cons && ... ) -> ConcatView< meta::AsView< Cons >... >

◆ CycleView()

template<typename Con>

di::container::CycleView ( Con && ) -> CycleView< meta::AsView< Con > >

◆ DropView()

template<typename Con>

di::container::DropView	(	Con &&	,
		meta::ContainerSSizeType< Con >	) -> DropView< meta::AsView< Con > >

◆ DropWhileView()

template<typename Con, typename Pred>

di::container::DropWhileView	(	Con &&	,
		Pred	) -> DropWhileView< meta::AsView< Con >, Pred >

◆ EnumerateView()

template<typename Con>

di::container::EnumerateView ( Con && ) -> EnumerateView< meta::AsView< Con > >

◆ FilterView()

template<typename Con, typename Pred>

di::container::FilterView	(	Con &&	,
		Pred	) -> FilterView< meta::AsView< Con >, Pred >

◆ FixedString()

template<types::size_t size>

di::container::FixedString ( char const(&)[size] ) -> FixedString< size - 1 >

◆ IotaView()

template<typename T, typename Bound>
requires (!concepts::Integer<T> || !concepts::Integer<Bound> || concepts::SignedInteger<T> == concepts::SignedInteger<Bound>)

di::container::IotaView	(	T	,
		Bound	) -> IotaView< T, Bound >

◆ JoinView()

template<typename Con>

di::container::JoinView ( Con && ) -> JoinView< meta::AsView< Con > >

explicit

◆ JoinWithView() [1/2]

template<concepts::InputContainer Con>

di::container::JoinWithView	(	Con &&	,
		meta::ContainerValue< meta::ContainerReference< Con > >	) -> JoinWithView< meta::AsView< Con >, SingleView< meta::ContainerValue< meta::ContainerReference< Con > > > >

◆ JoinWithView() [2/2]

template<typename Con, typename Pattern>

di::container::JoinWithView	(	Con &&	,
		Pattern &&	) -> JoinWithView< meta::AsView< Con >, meta::AsView< Pattern > >

◆ make_move_iterator()

template<concepts::InputIterator Iter>

auto di::container::make_move_iterator ( Iter iterator )

constexpr

◆ make_reverse_iterator()

template<concepts::BidirectionalIterator Iter>

auto di::container::make_reverse_iterator ( Iter iter )

constexpr

◆ operator-() [1/2]

template<typename Iter, typename U>

auto di::container::operator-	(	MoveIterator< Iter > const &	a,
		MoveIterator< U > const &	b ) -> decltype(a.base() - b.base())

constexpr

◆ operator-() [2/2]

template<typename Iter, typename U>

auto di::container::operator-	(	ReverseIterator< Iter > const &	a,
		ReverseIterator< U > const &	b ) -> decltype(b.base() - a.base())

constexpr

◆ operator<=>() [1/2]

template<typename Iter, concepts::ThreeWayComparableWith< Iter > U>

auto di::container::operator<=>	(	MoveIterator< Iter > const &	a,
		MoveIterator< U > const &	b )

constexpr

◆ operator<=>() [2/2]

template<typename Iter, concepts::ThreeWayComparableWith< Iter > U>

auto di::container::operator<=>	(	ReverseIterator< Iter > const &	a,
		ReverseIterator< U > const &	b )

constexpr

◆ operator==() [1/2]

template<typename Iter, concepts::EqualityComparableWith< Iter > U>

auto di::container::operator==	(	MoveIterator< Iter > const &	a,
		MoveIterator< U > const &	b ) -> bool

constexpr

◆ operator==() [2/2]

template<typename Iter, concepts::EqualityComparableWith< Iter > U>

auto di::container::operator==	(	ReverseIterator< Iter > const &	a,
		ReverseIterator< U > const &	b ) -> bool

constexpr

◆ PriorityQueue()

template<concepts::Container Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
requires (detail::PriorityQueueCompatible<Con, T>)

di::container::PriorityQueue	(	Comp	,
		Con	) -> PriorityQueue< T, Con, Comp >

◆ Queue()

template<concepts::Container Con, typename T = meta::ContainerValue<Con>>
requires (detail::QueueCompatible<Con, T>)

di::container::Queue ( Con ) -> Queue< T, Con >

◆ RefView()

template<typename Cont>

di::container::RefView ( Cont & ) -> RefView< Cont >

◆ RepeatView()

template<typename T, typename Bound>

di::container::RepeatView	(	T	,
		Bound	) -> RepeatView< T, Bound >

◆ ReverseView()

template<typename Con>

di::container::ReverseView ( Con && ) -> ReverseView< meta::AsView< Con > >

◆ sequence_to() [1/4]

template<typename Out, typename... Args>
requires (!concepts::View<Out>)

auto di::container::sequence_to ( Args &&... args )

constexpr

◆ sequence_to() [2/4]

template<template< typename... > typename Template, typename... Args>

auto di::container::sequence_to ( Args &&... args )

constexpr

◆ sequence_to() [3/4]

template<typename Out, concepts::InputContainer Con, typename... Args>
requires (!concepts::View<Out> && concepts::Expected<meta::ContainerValue<Con>>)

auto di::container::sequence_to	(	Con &&	container,
		Args &&...	args )

constexpr

◆ sequence_to() [4/4]

template<template< typename... > typename Template, concepts::InputContainer Con, typename... Args, typename UnwrappedContainer = EmptyView<meta::ExpectedValue<meta::ContainerValue<Con>>>>
requires (concepts::CreateDeducible<Template, UnwrappedContainer, Args...> || concepts::CreateDeducible<Template, FromContainer, UnwrappedContainer, Args...>)

auto di::container::sequence_to	(	Con &&	container,
		Args &&...	args )

constexpr

◆ SingleView()

template<typename T>

di::container::SingleView ( T ) -> SingleView< T >

◆ SlideView()

template<typename Con>

di::container::SlideView	(	Con &&	,
		meta::ContainerSSizeType< Con >	) -> SlideView< meta::AsView< Con > >

◆ SplitView() [1/2]

template<concepts::InputContainer Con>

di::container::SplitView	(	Con &&	,
		meta::ContainerValue< Con >	) -> SplitView< meta::AsView< Con >, SingleView< meta::ContainerValue< Con > > >

◆ SplitView() [2/2]

template<typename Con, typename Pattern>

di::container::SplitView	(	Con &&	,
		Pattern &&	) -> SplitView< meta::AsView< Con >, meta::AsView< Pattern > >

◆ Stack()

template<concepts::Container Con, typename T = meta::ContainerValue<Con>>
requires (detail::StackCompatible<Con, T>)

di::container::Stack ( Con ) -> Stack< T, Con >

◆ StrideView()

template<typename Con>

di::container::StrideView	(	Con &&	,
		meta::ContainerSSizeType< Con >	) -> StrideView< meta::AsView< Con > >

◆ tag_invoke() [1/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< LinkedList >	,
		Con &&	) -> LinkedList< T >

◆ tag_invoke() [2/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>>
requires (meta::TupleSize<T> == 2)

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< NodeHashMap >	,
		Con &&	) -> NodeHashMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >

◆ tag_invoke() [3/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq>
requires (meta::TupleSize<T> == 2)

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< NodeHashMap >	,
		Con &&	,
		Eq	) -> NodeHashMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq >

◆ tag_invoke() [4/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq, typename Hasher>
requires (meta::TupleSize<T> == 2)

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< NodeHashMap >	,
		Con &&	,
		Eq	,
		Hasher	) -> NodeHashMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq, Hasher >

◆ tag_invoke() [5/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>>
requires (meta::TupleSize<T> == 2)

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< NodeHashMultiMap >	,
		Con &&	) -> NodeHashMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >

◆ tag_invoke() [6/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq>
requires (meta::TupleSize<T> == 2)

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< NodeHashMultiMap >	,
		Con &&	,
		Eq	) -> NodeHashMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq >

◆ tag_invoke() [7/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq, typename Hasher>
requires (meta::TupleSize<T> == 2)

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< NodeHashMultiMap >	,
		Con &&	,
		Eq	,
		Hasher	) -> NodeHashMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq, Hasher >

◆ tag_invoke() [8/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< NodeHashMultiSet >	,
		Con &&	) -> NodeHashMultiSet< T >

◆ tag_invoke() [9/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< NodeHashMultiSet >	,
		Con &&	,
		Eq	) -> NodeHashMultiSet< T, Eq >

◆ tag_invoke() [10/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq, typename Hasher>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< NodeHashMultiSet >	,
		Con &&	,
		Eq	,
		Hasher	) -> NodeHashMultiSet< T, Eq, Hasher >

◆ tag_invoke() [11/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< NodeHashSet >	,
		Con &&	) -> NodeHashSet< T >

◆ tag_invoke() [12/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< NodeHashSet >	,
		Con &&	,
		Eq	) -> NodeHashSet< T, Eq >

◆ tag_invoke() [13/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq, typename Hasher>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< NodeHashSet >	,
		Con &&	,
		Eq	,
		Hasher	) -> NodeHashSet< T, Eq, Hasher >

◆ tag_invoke() [14/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< PriorityQueue >	,
		Con &&	) -> PriorityQueue< T >

◆ tag_invoke() [15/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< PriorityQueue >	,
		Con &&	,
		Comp	) -> PriorityQueue< T, container::Vector< T >, Comp >

◆ tag_invoke() [16/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< Queue >	,
		Con &&	) -> Queue< T >

◆ tag_invoke() [17/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< Ring >	,
		Con &&	) -> Ring< T >

◆ tag_invoke() [18/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< Stack >	,
		Con &&	) -> Stack< T >

◆ tag_invoke() [19/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>>
requires (meta::TupleSize<T> == 2)

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< TreeMap >	,
		Con &&	) -> TreeMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >

◆ tag_invoke() [20/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
requires (meta::TupleSize<T> == 2)

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< TreeMap >	,
		Con &&	,
		Comp	) -> TreeMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Comp >

◆ tag_invoke() [21/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>>
requires (meta::TupleSize<T> == 2)

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< TreeMultiMap >	,
		Con &&	) -> TreeMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >

◆ tag_invoke() [22/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
requires (meta::TupleSize<T> == 2)

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< TreeMultiMap >	,
		Con &&	,
		Comp	) -> TreeMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Comp >

◆ tag_invoke() [23/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< TreeMultiSet >	,
		Con &&	) -> TreeMultiSet< T >

◆ tag_invoke() [24/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< TreeMultiSet >	,
		Con &&	,
		Comp	) -> TreeMultiSet< T, Comp >

◆ tag_invoke() [25/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< TreeSet >	,
		Con &&	) -> TreeSet< T >

◆ tag_invoke() [26/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< TreeSet >	,
		Con &&	,
		Comp	) -> TreeSet< T, Comp >

◆ tag_invoke() [27/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>

auto di::container::tag_invoke	(	types::Tag< util::deduce_create >	,
		InPlaceTemplate< Vector >	,
		Con &&	) -> Vector< T >

◆ TakeView()

template<typename Con>

di::container::TakeView	(	Con &&	,
		meta::ContainerSSizeType< Con >	) -> TakeView< meta::AsView< Con > >

◆ TakeWhileView()

template<typename Con, typename Pred>

di::container::TakeWhileView	(	Con &&	,
		Pred	) -> TakeWhileView< meta::AsView< Con >, Pred >

◆ to() [1/4]

template<typename Out, typename... Args>
requires (!concepts::View<Out>)

auto di::container::to ( Args &&... args )

constexpr

◆ to() [2/4]

template<template< typename... > typename Template, typename... Args>

auto di::container::to ( Args &&... args )

constexpr

◆ to() [3/4]

template<typename Out, concepts::InputContainer Con, typename... Args>
requires (!concepts::View<Out>)

auto di::container::to	(	Con &&	container,
		Args &&...	args )

constexpr

◆ to() [4/4]

template<template< typename... > typename Template, concepts::InputContainer Con, typename... Args>
requires (concepts::CreateDeducible<Template, Con, Args...> || concepts::CreateDeducible<Template, FromContainer, Con, Args...>)

auto di::container::to	(	Con &&	container,
		Args &&...	args )

constexpr

◆ TransformView()

template<typename Con, typename F>

di::container::TransformView	(	Con &&	,
		F	) -> TransformView< meta::AsView< Con >, F >

◆ View() [1/4]

template<concepts::BorrowedContainer Cont>

di::container::View ( Cont && ) -> View< meta::ContainerIterator< Cont >, meta::ContainerSentinel< Cont >, concepts::SizedContainer< Cont >||concepts::SizedSentinelFor< meta::ContainerSentinel< Cont >, meta::ContainerIterator< Cont > > >

◆ View() [2/4]

template<concepts::BorrowedContainer Cont>

di::container::View	(	Cont &&	,
		meta::ContainerSizeType< Cont >	) -> View< meta::ContainerIterator< Cont >, meta::ContainerSentinel< Cont >, true >

◆ View() [3/4]

template<concepts::Iterator Iter, concepts::SentinelFor< Iter > Sent>

di::container::View	(	Iter	,
		Sent	) -> View< Iter, Sent >

◆ View() [4/4]

template<concepts::Iterator Iter, concepts::SentinelFor< Iter > Sent>

di::container::View	(	Iter	,
		Sent	,
		meta::IteratorSizeType< Iter >	) -> View< Iter, Sent, true >

◆ ZipTransformView()

template<class F, class... Cons>

di::container::ZipTransformView	(	F	,
		Cons &&	... ) -> ZipTransformView< F, meta::AsView< Cons >... >

◆ ZipView()

template<typename... Cons>

di::container::ZipView ( Cons && ... ) -> ZipView< meta::AsView< Cons >... >

Variable Documentation

◆ adjacent_find

auto di::container::adjacent_find = detail::AdjacentFindFunction {}

inlineconstexpr

◆ advance

auto di::container::advance = AdvanceFunction {}

inlineconstexpr

◆ all_of

auto di::container::all_of = detail::AllOfFunction {}

inlineconstexpr

◆ allocate

auto di::container::allocate = detail::AllocateFunction {}

inlineconstexpr

◆ allocate_many

template<typename T>

auto di::container::allocate_many = detail::AllocateManyFunction<T> {}

inlineconstexpr

◆ allocate_one

template<typename T>

auto di::container::allocate_one = detail::AllocateOneFunction<T> {}

inlineconstexpr

◆ any_of

auto di::container::any_of = detail::AnyOfFunction {}

inlineconstexpr

◆ at

auto di::container::at = di::curry_back(detail::AtFunction {}, c_<2ZU>)

inlineconstexpr

◆ at_unchecked

auto di::container::at_unchecked = di::curry_back(detail::AtUncheckedFunction {}, c_<2ZU>)

inlineconstexpr

◆ back

auto di::container::back = detail::BackFunction {}

inlineconstexpr

◆ back_unchecked

auto di::container::back_unchecked = detail::BackUncheckedFunction {}

inlineconstexpr

◆ begin

auto di::container::begin = BeginFunction {}

inlineconstexpr

◆ binary_search

auto di::container::binary_search = detail::BinarySearchFunction {}

inlineconstexpr

◆ cbegin

auto di::container::cbegin = CBeginFunction {}

inlineconstexpr

◆ cdata

auto di::container::cdata = CDataFunction {}

inlineconstexpr

◆ cend

auto di::container::cend = CEndFunction {}

inlineconstexpr

◆ compare

auto di::container::compare = detail::CompareFunction {}

inlineconstexpr

◆ contains

auto di::container::contains = detail::ContainsFunction {}

inlineconstexpr

◆ contains_subrange

auto di::container::contains_subrange = detail::ContainsSubrangeFunction {}

inlineconstexpr

◆ copy

auto di::container::copy = detail::CopyFunction {}

inlineconstexpr

◆ copy_backward

auto di::container::copy_backward = detail::CopyBackwardFunction {}

inlineconstexpr

◆ copy_if

auto di::container::copy_if = detail::CopyIfFunction {}

inlineconstexpr

◆ copy_n

auto di::container::copy_n = detail::CopyNFunction {}

inlineconstexpr

◆ count

auto di::container::count = detail::CountFunction {}

inlineconstexpr

◆ count_if

auto di::container::count_if = detail::CountIfFunction {}

inlineconstexpr

◆ crbegin

auto di::container::crbegin = CRBeginFunction {}

inlineconstexpr

◆ crend

auto di::container::crend = CREndFunction {}

inlineconstexpr

◆ data

auto di::container::data = DataFunction {}

inlineconstexpr

◆ deallocate

auto di::container::deallocate = detail::DeallocateFunction {}

inlineconstexpr

◆ deallocate_many

template<typename T>

auto di::container::deallocate_many = detail::DeallocateManyFunction<T> {}

inlineconstexpr

◆ deallocate_one

template<typename T>

auto di::container::deallocate_one = detail::DeallocateOneFunction<T> {}

inlineconstexpr

◆ default_sentinel

auto di::container::default_sentinel = DefaultSentinel {}

inlineconstexpr

◆ destroy

auto di::container::destroy = detail::DestroyFunction {}

inlineconstexpr

◆ destroy_n

auto di::container::destroy_n = detail::DestroyNFunction {}

inlineconstexpr

◆ distance

auto di::container::distance = detail::DistanceFunction {}

inlineconstexpr

◆ empty

auto di::container::empty = EmptyFunction {}

inlineconstexpr

◆ enable_borrowed_container

struct di::container::EnableBorrowedContainer di::container::enable_borrowed_container

◆ enable_view

struct di::container::EnableViewFunction di::container::enable_view

◆ end

auto di::container::end = EndFunction {}

inlineconstexpr

◆ ends_with

auto di::container::ends_with = detail::EndsWithFunction {}

inlineconstexpr

◆ equal

auto di::container::equal = detail::EqualFunction {}

inlineconstexpr

◆ equal_range

auto di::container::equal_range = detail::EqualRangeFunction {}

inlineconstexpr

◆ erase

auto di::container::erase = erase_ns::EraseFunction {}

inlineconstexpr

◆ erase_if

auto di::container::erase_if = erase_ns::EraseIfFunction {}

inlineconstexpr

◆ fail_allocator

auto di::container::fail_allocator = FailAllocator {}

inlineconstexpr

◆ fill

auto di::container::fill = detail::FillFunction {}

inlineconstexpr

◆ fill_n

auto di::container::fill_n = detail::FillNFunction {}

inlineconstexpr

◆ find

auto di::container::find = detail::FindFunction {}

inlineconstexpr

◆ find_end

auto di::container::find_end = detail::FindEndFunction {}

inlineconstexpr

◆ find_first_not_of

auto di::container::find_first_not_of = detail::FindFirstNotOfFunction {}

inlineconstexpr

◆ find_first_of

auto di::container::find_first_of = detail::FindFirstOfFunction {}

inlineconstexpr

◆ find_if

auto di::container::find_if = detail::FindIfFunction {}

inlineconstexpr

◆ find_if_not

auto di::container::find_if_not = detail::FindIfNotFunction {}

inlineconstexpr

◆ find_last

auto di::container::find_last = detail::FindLastFunction {}

inlineconstexpr

◆ find_last_if

auto di::container::find_last_if = detail::FindLastIfFunction {}

inlineconstexpr

◆ find_last_if_not

auto di::container::find_last_if_not = detail::FindLastIfNotFunction {}

inlineconstexpr

◆ find_last_not_of

auto di::container::find_last_not_of = detail::FindLastNotOfFunction {}

inlineconstexpr

◆ find_last_of

auto di::container::find_last_of = detail::FindLastOfFunction {}

inlineconstexpr

◆ fixed_string_concat

auto di::container::fixed_string_concat = detail::FixedStringConcat {}

inlineconstexpr

◆ fixed_string_to_utf8_string_view

template<FixedString literal>

auto di::container::fixed_string_to_utf8_string_view = detail::FixedStringToUtf8StringViewFunction<literal> {}

inlineconstexpr

◆ fold_left

auto di::container::fold_left = function::curry_back(detail::FoldLeftFunction {}, meta::c_<3ZU>)

inlineconstexpr

◆ fold_left_first

auto di::container::fold_left_first = function::curry_back(detail::FoldLeftFirstFunction {}, meta::c_<2ZU>)

inlineconstexpr

◆ fold_left_first_with_iter

auto di::container::fold_left_first_with_iter = detail::FoldLeftFirstWithIterFunction {}

inlineconstexpr

◆ fold_left_with_iter

auto di::container::fold_left_with_iter = detail::FoldLeftWithIterFunction {}

inlineconstexpr

◆ fold_right

auto di::container::fold_right = detail::FoldRightFunction {}

inlineconstexpr

◆ fold_right_last

auto di::container::fold_right_last = detail::FoldRightLastFunction {}

inlineconstexpr

◆ for_each

auto di::container::for_each = detail::ForEachFunction {}

inlineconstexpr

◆ for_each_n

auto di::container::for_each_n = detail::ForEachNFunction {}

inlineconstexpr

◆ front

auto di::container::front = detail::FrontFunction {}

inlineconstexpr

◆ front_unchecked

auto di::container::front_unchecked = detail::FrontUncheckedFunction {}

inlineconstexpr

◆ generate

auto di::container::generate = detail::GenerateFunction {}

inlineconstexpr

◆ generate_n

auto di::container::generate_n = detail::GenerateNFunction {}

inlineconstexpr

◆ hash

auto di::container::hash = detail::HashFunction {}

inlineconstexpr

◆ hash_same

auto di::container::hash_same = detail::HashSameFunction {}

inlineconstexpr

◆ hash_write

auto di::container::hash_write = detail::HashWriteFunction {}

inlineconstexpr

◆ includes

auto di::container::includes = detail::IncludesFunction {}

inlineconstexpr

◆ into_erased_string

auto di::container::into_erased_string = detail::IntoErasedStringFunction {}

inlineconstexpr

◆ iota

auto di::container::iota = detail::IotaFunction {}

inlineconstexpr

◆ is_heap

auto di::container::is_heap = detail::IsHeapFunction {}

inlineconstexpr

◆ is_heap_until

auto di::container::is_heap_until = detail::IsHeapUntilFunction {}

inlineconstexpr

◆ is_partitioned

auto di::container::is_partitioned = detail::IsPartitionedFunction {}

inlineconstexpr

◆ is_permutation

auto di::container::is_permutation = detail::IsPermutationFunction {}

inlineconstexpr

◆ is_sorted

auto di::container::is_sorted = detail::IsSortedFunction {}

inlineconstexpr

◆ is_sorted_until

auto di::container::is_sorted_until = detail::IsSortedUntilFunction {}

inlineconstexpr

◆ iterator_category

struct di::container::IteratorCategoryFunction di::container::iterator_category

◆ iterator_move

auto di::container::iterator_move = detail::IteratorMoveFunction {}

inlineconstexpr

◆ iterator_ssize_type

struct di::container::IteratorSSizeTypeFunction di::container::iterator_ssize_type

◆ iterator_swap

auto di::container::iterator_swap = detail::IteratorSwapFunction {}

inlineconstexpr

◆ iterator_value

struct di::container::IteratorValueFunction di::container::iterator_value

◆ lower_bound

auto di::container::lower_bound = detail::LowerBoundFunction {}

inlineconstexpr

◆ make_heap

auto di::container::make_heap = detail::MakeHeapFunction {}

inlineconstexpr

◆ max

auto di::container::max = detail::MaxFunction {}

inlineconstexpr

◆ max_element

auto di::container::max_element = detail::MaxElementFunction {}

inlineconstexpr

◆ merge

auto di::container::merge = detail::MergeFunction {}

inlineconstexpr

◆ min

auto di::container::min = detail::MinFunction {}

inlineconstexpr

◆ min_element

auto di::container::min_element = detail::MinElementFunction {}

inlineconstexpr

◆ minmax

auto di::container::minmax = detail::MinMaxFunction {}

inlineconstexpr

◆ minmax_element

auto di::container::minmax_element = detail::MinMaxElementFunction {}

inlineconstexpr

◆ mismatch

auto di::container::mismatch = detail::MismatchFunction {}

inlineconstexpr

◆ move

auto di::container::move = detail::MoveFunction {}

inlineconstexpr

◆ move_backward

auto di::container::move_backward = detail::MoveBackwardFunction {}

inlineconstexpr

◆ next

auto di::container::next = NextFunction {}

inlineconstexpr

◆ next_permutation

auto di::container::next_permutation = detail::NextPermutationFunction {}

inlineconstexpr

◆ none_of

auto di::container::none_of = detail::NoneOfFunction {}

inlineconstexpr

◆ partition

auto di::container::partition = detail::PartitionFunction {}

inlineconstexpr

◆ partition_copy

auto di::container::partition_copy = detail::PartitionCopyFunction {}

inlineconstexpr

◆ partition_point

auto di::container::partition_point = detail::PartitionPointFunction {}

inlineconstexpr

◆ pop_heap

auto di::container::pop_heap = detail::PopHeapFunction {}

inlineconstexpr

◆ prev

auto di::container::prev = PrevFunction {}

inlineconstexpr

◆ prev_permutation

auto di::container::prev_permutation = detail::PrevPermutationFunction {}

inlineconstexpr

◆ product

auto di::container::product = detail::ProductFunction {}

inlineconstexpr

◆ push_heap

auto di::container::push_heap = detail::PushHeapFunction {}

inlineconstexpr

◆ rbegin

auto di::container::rbegin = RBeginFunction {}

inlineconstexpr

◆ reconstruct

auto di::container::reconstruct = ReconstructFunction {}

inlineconstexpr

◆ remove

auto di::container::remove = detail::RemoveFunction {}

inlineconstexpr

◆ remove_copy

auto di::container::remove_copy = detail::RemoveCopyFunction {}

inlineconstexpr

◆ remove_copy_if

auto di::container::remove_copy_if = detail::RemoveCopyIfFunction {}

inlineconstexpr

◆ remove_if

auto di::container::remove_if = detail::RemoveIfFunction {}

inlineconstexpr

◆ rend

auto di::container::rend = REndFunction {}

inlineconstexpr

◆ replace

auto di::container::replace = detail::ReplaceFunction {}

inlineconstexpr

◆ replace_copy

auto di::container::replace_copy = detail::ReplaceCopyFunction {}

inlineconstexpr

◆ replace_copy_if

auto di::container::replace_copy_if = detail::ReplaceCopyIfFunction {}

inlineconstexpr

◆ replace_if

auto di::container::replace_if = detail::ReplaceIfFunction {}

inlineconstexpr

◆ reverse

auto di::container::reverse = detail::ReverseFunction {}

inlineconstexpr

◆ reverse_copy

auto di::container::reverse_copy = detail::ReverseCopyFunction {}

inlineconstexpr

◆ rotate

auto di::container::rotate = detail::RotateFunction {}

inlineconstexpr

◆ rotate_copy

auto di::container::rotate_copy = detail::RotateCopyFunction {}

inlineconstexpr

◆ sample

auto di::container::sample = detail::SampleFunction {}

inlineconstexpr

◆ search

auto di::container::search = detail::SearchFunction {}

inlineconstexpr

◆ search_n

auto di::container::search_n = detail::SearchNFunction {}

inlineconstexpr

◆ sequence

auto di::container::sequence = function::curry_back(detail::SequenceFunction {}, meta::c_<2ZU>)

inlineconstexpr

◆ set_difference

auto di::container::set_difference = detail::SetDifferenceFunction {}

inlineconstexpr

◆ set_intersection

auto di::container::set_intersection = detail::SetIntersectionFunction {}

inlineconstexpr

◆ set_symmetric_difference

auto di::container::set_symmetric_difference = detail::SetSymmetricDifferenceFunction {}

inlineconstexpr

◆ set_union

auto di::container::set_union = detail::SetUnionFunction {}

inlineconstexpr

◆ shift_left

auto di::container::shift_left = detail::ShiftLeftFunction {}

inlineconstexpr

◆ shift_right

auto di::container::shift_right = detail::ShiftRightFunction {}

inlineconstexpr

◆ shuffle

auto di::container::shuffle = detail::ShuffleFunction {}

inlineconstexpr

◆ size

auto di::container::size = SizeFunction {}

inlineconstexpr

◆ sort

auto di::container::sort = detail::SortFunction {}

inlineconstexpr

◆ sort_heap

auto di::container::sort_heap = detail::SortHeapFunction {}

inlineconstexpr

◆ ssize

auto di::container::ssize = SSizeFunction {}

inlineconstexpr

◆ stable_partition

auto di::container::stable_partition = detail::StablePartitionFunction {}

inlineconstexpr

◆ starts_with

auto di::container::starts_with = detail::StartsWithFunction {}

inlineconstexpr

◆ sum

auto di::container::sum = detail::SumFunction {}

inlineconstexpr

◆ swap_ranges

auto di::container::swap_ranges = detail::SwapRanges {}

inlineconstexpr

◆ transform

auto di::container::transform = detail::TransformFunction {}

inlineconstexpr

◆ uninitialized_copy

auto di::container::uninitialized_copy = detail::UninitializedCopyFunction {}

inlineconstexpr

◆ uninitialized_copy_n

auto di::container::uninitialized_copy_n = detail::UninitializedCopyNFunction {}

inlineconstexpr

◆ uninitialized_default_construct

auto di::container::uninitialized_default_construct = detail::UninitializedDefaultConstructFunction {}

inlineconstexpr

◆ uninitialized_default_construct_n

auto di::container::uninitialized_default_construct_n = detail::UninitializedDefaultConstructNFunction {}

inlineconstexpr

◆ uninitialized_fill

auto di::container::uninitialized_fill = detail::UninitializedFillFunction {}

inlineconstexpr

◆ uninitialized_fill_n

auto di::container::uninitialized_fill_n = detail::UninitializedFillNFunction {}

inlineconstexpr

◆ uninitialized_move

auto di::container::uninitialized_move = detail::UninitializedMoveFunction {}

inlineconstexpr

◆ uninitialized_move_n

auto di::container::uninitialized_move_n = detail::UninitializedMoveNFunction {}

inlineconstexpr

◆ uninitialized_relocate

auto di::container::uninitialized_relocate = detail::UninitializedRelocateFunction {}

inlineconstexpr

◆ uninitialized_relocate_backwards

auto di::container::uninitialized_relocate_backwards = detail::UninitializedRelocateBackwardsFunction {}

inlineconstexpr

◆ uninitialized_value_construct

auto di::container::uninitialized_value_construct = detail::UninitializedValueConstructFunction {}

inlineconstexpr

◆ uninitialized_value_construct_n

auto di::container::uninitialized_value_construct_n = detail::UninitializedValueConstructNFunction {}

inlineconstexpr

◆ unique

auto di::container::unique = detail::UniqueFunction {}

inlineconstexpr

◆ unique_copy

auto di::container::unique_copy = detail::UniqueCopyFunction {}

inlineconstexpr

◆ unreachable_sentinel

auto di::container::unreachable_sentinel = UnreachableSentinel {}

inlineconstexpr

◆ upper_bound

auto di::container::upper_bound = detail::UpperBoundFunction {}

inlineconstexpr

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ IntrusiveHashSetNode

◆ IntrusiveTreeSetNode

◆ KeysView

◆ MoveBackwardResult

◆ MoveResult

◆ Path

◆ PathView

◆ StdAllocator

◆ String

◆ StringView

◆ TransparentString

◆ TransparentStringView

◆ UninitializedRelocateBackwardsResult

◆ UninitializedRelocateResult

◆ Utf8Path

◆ Utf8PathView

◆ ValuesView

◆ ZC16CString

◆ ZC16String

◆ ZC32CString

◆ ZC32String

◆ ZC8CString

◆ ZC8String

◆ ZCString

◆ ZCUString

◆ ZCWString

◆ ZString

◆ ZUString

◆ ZWString

Function Documentation

◆ AsConstView()

◆ AsRValueView()

◆ CartesianProductView()

◆ ChunkByView()

◆ ChunkView()

◆ CommonView()

◆ ConcatView()

◆ CycleView()

◆ DropView()

◆ DropWhileView()

◆ EnumerateView()

◆ FilterView()

◆ FixedString()

◆ IotaView()

◆ JoinView()

◆ JoinWithView() [1/2]

◆ JoinWithView() [2/2]

◆ make_move_iterator()

◆ make_reverse_iterator()

◆ operator-() [1/2]

◆ operator-() [2/2]

◆ operator<=>() [1/2]

◆ operator<=>() [2/2]

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ PriorityQueue()

◆ Queue()

◆ RefView()

◆ RepeatView()

◆ ReverseView()

◆ sequence_to() [1/4]

◆ sequence_to() [2/4]

◆ sequence_to() [3/4]

◆ sequence_to() [4/4]

◆ SingleView()

◆ SlideView()

◆ SplitView() [1/2]

◆ SplitView() [2/2]

◆ Stack()

◆ StrideView()

◆ tag_invoke() [1/27]

◆ tag_invoke() [2/27]

◆ tag_invoke() [3/27]

◆ tag_invoke() [4/27]