Namespaces
namespace	concepts
namespace	any
namespace	meta
namespace	types
namespace	assert
namespace	bit
namespace	chrono
namespace	literals
namespace	chrono_duration_literals
namespace	cli
namespace	container
namespace	path_literals
namespace	path_view_literals
namespace	string_literals
namespace	string_view_literals
namespace	exec
namespace	execution
namespace	vocab
namespace	fmt
namespace	function
namespace	io
namespace	math
namespace	numbers
namespace	util
namespace	parser
namespace	constexpr_integral_literals
namespace	integral_literals
namespace	integral_set_literals
namespace	platform
namespace	random
namespace	reflection
namespace	serialization
namespace	base64_literals
namespace	json_literals
namespace	percent_encoded_literals
namespace	sync
namespace	test
namespace	uuid_literals

Classes
struct	Method
struct	This
class	BitSet
struct	BitEnum
struct	BitField
struct	BitFlag
class	BitStruct
class	BigEndian
class	LittleEndian
class	Duration
class	TimePoint
struct	AllocationResult
struct	FailAllocator
struct	FallibleAllocator
struct	InfallibleAllocator
struct	DefaultHasher
class	NodeHashMap
class	NodeHashMultiMap
class	NodeHashMultiSet
class	NodeHashSet
class	IntrusiveForwardList
struct	IntrusiveForwardListTag
class	IntrusiveForwardListNode
class	IntrusiveHashMultiSet
class	IntrusiveHashSet
struct	IntrusiveHashSetTag
class	IntrusiveList
struct	IntrusiveListTag
class	IntrusiveListNode
class	IntrusiveTreeMultiSet
class	IntrusiveTreeSet
struct	IntrusiveTreeSetTag
struct	DefaultSentinel
class	LinkedList
class	PriorityQueue
class	Queue
class	Stack
class	Ring
class	StaticRing
class	ErasedString
class	FixedString
class	Utf8StreamDecoder
class	Utf8StrictStreamDecoder
class	TreeMap
class	TreeMultiMap
class	TreeMultiSet
class	TreeSet
struct	BidirectionalIteratorTag
struct	ContiguousIteratorTag
struct	ElementsOf
struct	ForwardIteratorTag
struct	FromContainer
struct	InputIteratorTag
struct	RandomAccessIteratorTag
class	StaticVector
class	Vector
class	View
struct	InlineScheduler
class	RunLoop
class	Lazy
class	WithAwaitableSenders
struct	Protocol
struct	SetError
struct	SetStopped
struct	SetValue
struct	SequenceTag
struct	CompletionSignatures
struct	EmptyEnv
class	FormatParseContext
class	Styled
struct	AsBool
struct	BetweenExclusive
struct	BetweenInclusive
struct	BitAnd
struct	Compare
struct	CompareBackwards
class	Function
class	FunctionRef
struct	Curry
struct	CurryBack
struct	Dereference
struct	Equal
struct	EqualOrGreater
struct	EqualOrLess
class	Generator
struct	Greater
struct	Identity
struct	Less
struct	Minus
struct	Multiplies
struct	NotEqual
struct	Plus
class	SizeWriter
class	StringReader
class	StringWriter
class	VectorReader
class	VectorWriter
class	FixedSigned
	A fixed-width signed integer. More...
class	FixedUnsigned
	A fixed-width unsigned integer. More...
class	Checked
struct	NumericLimits
struct	Ratio
class	Rational
struct	Constexpr
	A wrapper for a constexpr value. More...
class	GenericDomain
class	UniformIntDistribution
class	LinearCongruentialEngine
struct	Atom
struct	Enumerator
struct	Enumerators
struct	Field
struct	Fields
class	Base64
class	BinaryDeserializer
	A deserializer for a simple binary format. More...
struct	BinaryFormat
class	BinarySerializer
	A serializer for a simple binary format. More...
class	JsonDeserializer
	A deserializer for the JSON format. More...
struct	JsonFormat
class	JsonSerializer
class	JsonSerializerConfig
class	PercentEncoded
	Helper class for performing percent encoding. More...
class	Atomic
class	AtomicRef
class	DumbConditionVariable
class	DumbSpinlock
class	ScopedLock
class	InPlaceStopCallback
class	InPlaceStopSource
class	InPlaceStopToken
class	NeverStopToken
class	Synchronized
struct	AdoptLock
struct	DeferLock
struct	TryToLock
class	UniqueLock
struct	InPlace
struct	InPlaceTemplate
struct	InPlaceType
struct	PiecewiseConstruct
struct	Void
class	Badge
class	DeferConstruct
class	GuardedReference
struct	Immovable
class	MovableBox
class	NamedArgument
	A helper class to simulate a single named argument. More...
class	NamedArguments
	A helper class for simulation named arguments in c++. More...
class	NonPropagatingCache
struct	NonCopyable
class	RebindableBox
class	ReferenceWrapper
class	ScopeExit
class	ScopeValueChange
struct	SelfPointer
class	SourceLocation
struct	StoreIf
class	StrongInt
class	UUID
struct	Array
class	StatusCode
class	StatusCodeDomain
class	StringError
class	Expected
class	Unexpected
class	DefaultAccessor
class	Extents
struct	LayoutLeft
struct	LayoutRight
struct	LayoutStride
class	MDSpan
class	Optional
struct	IntrusiveRefCount
class	Box
struct	DefaultDelete
struct	AdoptObject
class	IntrusivePtr
struct	RetainObject
struct	IntrusiveThreadUnsafeRefCount
class	Span
class	Tuple
class	Variant

Typedefs
using	FormatColor = fmt::Color
using	FormatBackgroundColor = fmt::BackgroundColor
using	FormatEffect = fmt::Effect
using	Base64View = Base64<di::Span<byte const>>
using	PercentEncodedView = PercentEncoded<di::TransparentStringView>
template<typename Promise = void>
using	CoroutineHandle = std::coroutine_handle<Promise>
using	NoopCoroutineHandle = std::noop_coroutine_handle
using	NoopCoroutinePromise = std::noop_coroutine_promise
using	SuspendAlways = std::suspend_always
using	SuspendNever = std::suspend_never
using	ByteBuffer = vocab::byte_buffer::ByteBufferImpl<>
using	ExclusiveByteBuffer = vocab::byte_buffer::ExclusiveByteBufferImpl<>
template<concepts::Interface UserInterface, concepts::AnyStorage Storage = HybridStorage<>, typename VTablePolicy = MaybeInlineVTable<3>>
using	Any
template<concepts::Interface Interface, StorageCategory storage_category = StorageCategory::MoveOnly, size_t inline_size = 2 * sizeof(void), size_t inline_align = alignof(void), concepts::Allocator Alloc = platform::DefaultAllocator>
using	AnyHybrid
template<concepts::Interface Interface, size_t inline_size = 2 * sizeof(void), size_t inline_align = alignof(void)>
using	AnyInline
template<concepts::Interface Interface>
using	AnyRef
template<concepts::Interface Interface, concepts::Allocator Alloc = platform::DefaultAllocator>
using	AnyShared
template<concepts::Interface Interface, concepts::Allocator Alloc = platform::DefaultAllocator>
using	AnyUnique
template<typename Self, concepts::LanguageFunction Sig, typename... Tags>
using	Dispatcher
template<concepts::IntegralOrEnum T, Endian endian>
using	StaticEndian
using	Days
using	Hours
using	Microseconds
using	Milliseconds
using	Minutes
using	Months
using	Nanoseconds
using	Picoseconds
using	Seconds
using	Years
template<concepts::Allocator Alloc, typename T = void>
using	AllocatorResult
template<typename Tag>
using	IntrusiveHashSetNode
template<typename Tag = DefaultIntrusiveTreeSetTag>
using	IntrusiveTreeSetNode
using	Path
using	Utf8Path
using	PathView
using	Utf8PathView
using	String
using	TransparentString
using	StringView
using	TransparentStringView
using	ZC16CString
using	ZC16String
using	ZC32CString
using	ZC32String
using	ZC8CString
using	ZC8String
using	ZCString
using	ZCUString
using	ZCWString
using	ZString
using	ZUString
using	ZWString
using	Stopped
template<typename Env = void, concepts::AnyStorage Storage = any::HybridStorage<any::StorageCategory::MoveOnly, 8 * sizeof(void), alignof(void)>, typename VTablePolicy = any::MaybeInlineVTable<3>>
using	AnyOperationState
template<concepts::ValidCompletionSignatures Sigs, typename Env = void, concepts::AnyStorage Storage = any::InlineStorage<2 * sizeof(void), alignof(void)>, typename VTablePolicy = any::MaybeInlineVTable<3>>
using	AnyReceiver
template<concepts::ValidCompletionSignatures Sigs, typename Env = void, concepts::AnyStorage Storage = any::HybridStorage<>, typename VTablePolicy = any::MaybeInlineVTable<3>, concepts::OperationState Op = AnyOperationState<>, typename Rec = AnyReceiver<detail::AnySigs<Sigs>>>
using	AnySender
template<typename T = void>
using	AnySenderOf
template<concepts::ClassType Self, concepts::Receiver Base = receiver_interface_ns::fake_receiver::FakeReceiver>
using	ReceiverAdaptor
template<concepts::Allocator Alloc = platform::DefaultAllocator>
using	CountingScope
	A scope that waits for all spawned senders to complete.
template<typename Ref, typename Value = void>
using	AsyncGenerator
template<concepts::Encoding Enc, concepts::Formattable... Args>
using	FormatStringImpl
template<typename... Ts>
using	InvokeResult
template<typename Tag, typename... Args>
using	TagInvokeResult
template<auto & T>
using	Tag
using	Reader
using	Writer
using	i128_fallback
using	i256
using	u128_fallback
using	u256
template<detail::IsRatio A, detail::IsRatio B>
using	RatioAdd
template<detail::IsRatio A, detail::IsRatio B>
using	RatioDivide
template<detail::IsRatio A, detail::IsRatio B>
using	RatioMultiply
template<detail::IsRatio A, detail::IsRatio B>
using	RatioSubtract
template<detail::IsRatio A, detail::IsRatio B>
using	RatioEqual
template<detail::IsRatio A, detail::IsRatio B>
using	RatioGreater
template<detail::IsRatio A, detail::IsRatio B>
using	RatioGreaterEqual
template<detail::IsRatio A, detail::IsRatio B>
using	RatioLess
template<detail::IsRatio A, detail::IsRatio B>
using	RatioLessEqual
template<detail::IsRatio A, detail::IsRatio B>
using	RatioNotEqual
template<typename F, typename... Args>
using	CallResult
using	DefaultAllocator
using	DefaultFallibleAllocator
using	DefaultLock
using	ThreadId
using	MinstdRand
using	MinstdRand0
template<concepts::Reflectable T>
using	Reflect
template<concepts::DeserializationFormat S, typename T>
using	DeserializeMetadata
template<typename S, typename T>
using	DeserializeResult
template<concepts::SerializationFormat S, typename T>
using	SerializeMetadata
template<typename S>
using	SerializeResult
using	Byte
using	byte
using	c16
using	c32
using	c8
using	f32
using	f64
using	i16
using	i32
using	i64
using	i8
using	u16
using	u32
using	u64
using	u8
using	imax
using	iptr
using	isize
using	umax
using	uptr
using	usize
using	intptr_t
using	nullptr_t
using	ptrdiff_t
using	size_t
using	ssize_t
using	uintptr_t
using	Error
template<typename T = void>
using	Result
using	GenericCode
using	StringErrorCode
template<typename SizeType, usize rank>
using	Dextents
template<typename T>
using	Arc
template<typename T>
using	Arc
template<typename T>
using	Rc
template<typename T>
using	Rc

Enumerations
enum class	StorageCategory
enum class	Endian
enum class	BasicError
enum class	MemoryOrder

Functions
constexpr auto	operator""_h (unsigned long long value)
constexpr auto	operator""_min (unsigned long long value)
constexpr auto	operator""_s (unsigned long long value)
constexpr auto	operator""_ms (unsigned long long value)
constexpr auto	operator""_us (unsigned long long value)
constexpr auto	operator""_ns (unsigned long long value)
constexpr auto	operator""_ps (unsigned long long value)
template<container::FixedString literal>
constexpr auto	operator""_u8p ()
constexpr auto	operator""_u8p (c8 const *data, size_t size)
constexpr auto	operator""_p (char const *data, size_t size)
template<container::FixedString literal>
consteval auto	operator""_u8pv ()
consteval auto	operator""_u8pv (c8 const *data, size_t size)
consteval auto	operator""_pv (char const *data, size_t size)
template<container::FixedString literal>
constexpr auto	operator""_s ()
constexpr auto	operator""_s (c8 const *data, size_t size)
constexpr auto	operator""_ts (char const *data, size_t size)
template<container::FixedString literal>
consteval auto	operator""_sv ()
consteval auto	operator""_sv (c8 const *data, size_t size)
consteval auto	operator""_tsv (char const *data, size_t size)
template<char... chars>
constexpr auto	operator""_zic ()
consteval auto	operator""_b (unsigned long long value) -> Byte
consteval auto	operator""_b (char value) -> Byte
constexpr auto	operator""_base64 (char const *data, usize size) -> serialization::Base64<>
template<container::FixedString string> requires (detail::valid_json_literal<string>())
constexpr auto	operator""_json ()
constexpr auto	operator""_percent_encoded (char const *data, usize size) -> serialization::PercentEncoded<>
consteval auto	operator""_uuid (char const *data, usize size) -> util::UUID
template<concepts::Object T>
constexpr auto	cli_parser (TransparentStringView app_name, StringView description)
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<typename Out, concepts::InputContainer Con, typename... Args> requires (!concepts::View<Out>)
constexpr auto	to (Con &&container, Args &&... args)
template<typename F, typename... Args> requires (concepts::ConstructibleFrom<meta::Decay<F>, F> && (concepts::ConstructibleFrom<meta::Decay<Args>, Args> && ...))
constexpr auto	bind_back (F &&f, Args &&... args)
template<typename F, typename... Args> requires (concepts::ConstructibleFrom<meta::Decay<F>, F> && (concepts::ConstructibleFrom<meta::Decay<Args>, Args> && ...))
constexpr auto	bind_front (F &&f, Args &&... args)
template<typename F> requires (concepts::ConstructibleFrom<meta::Decay<F>, F>)
constexpr auto	chain (F &&f)
template<typename F> requires (concepts::ConstructibleFrom<meta::Decay<F>, F>)
constexpr auto	compose (F &&f)
template<concepts::DecayConstructible F>
constexpr auto	flip (F &&function)
template<concepts::DecayConstructible F>
constexpr auto	not_fn (F &&function)
template<typename F> requires (concepts::ConstructibleFrom<meta::Decay<F>, F>)
constexpr auto	piped (F &&function)
auto	get_current_thread_id () -> ThreadId
void	cpu_relax ()
template<typename T>
constexpr auto	as_const_pointer (T const *pointer)
template<concepts::CopyConstructible T>
auto	black_box (T const &value) -> T
template<auto... values>
void	compile_time_fail ()
constexpr void	compiler_barrier ()
	Force to optimizer to reload memory addresses.
template<typename T, typename... Args> requires (concepts::LanguageVoid<T> \|\| concepts::CreatableFrom<T, Args...>)
constexpr auto	create (Args &&... args)
template<typename T>
auto	declval () -> meta::AddRValueReference< T >
template<typename T, typename U = T>
constexpr auto	exchange (T &object, U &&new_value) -> T
template<typename Derived, typename Base> requires (concepts::DerivedFrom<meta::RemoveCVRef<Derived>, Base>)
constexpr auto	forward_as_base (meta::RemoveReference< Derived > &derived) -> meta::Like< meta::RemoveReference< Derived > &, Base > &&
template<typename T, typename U>
constexpr auto	forward_like (U &&value) -> decltype(auto)
template<types::size_t index, typename T>
constexpr auto	get (T &&value) -> decltype(auto)
constexpr auto	is_constant_evaluated () noexcept -> bool
void	unreachable ()
template<typename T, types::size_t size> requires (concepts::CopyConstructible<T> && !concepts::LanguageArray<T>)
constexpr auto	to_array (T(&array)[size])
template<typename T>
constexpr auto	make_optional (T &&value)
template<size_t count, typename T>
constexpr auto	fixed_span (T *value) -> Span< T, count >
template<size_t count, typename T>
constexpr auto	fixed_span (T *value) -> Span< T, count >
template<typename F, concepts::TupleLike Tup>
constexpr auto	apply (F &&f, Tup &&tuple) -> decltype(detail::apply_impl(meta::MakeIndexSequence< meta::TupleSize< Tup > > {}, util::forward< F >(f), util::forward< Tup >(tuple)))
template<typename F, concepts::TupleLike Tup>
constexpr auto	apply_reverse (F &&f, Tup &&tuple) -> decltype(detail::apply_impl(meta::MakeReverseIndexSequence< meta::TupleSize< Tup > > {}, util::forward< F >(f), util::forward< Tup >(tuple)))
template<typename... Args>
constexpr auto	forward_as_tuple (Args &&... args) -> Tuple< Args &&... >
template<typename... Args>
constexpr auto	make_decayed_tuple (Args &&... args)
template<typename... Args>
constexpr auto	make_tuple (Args &&... args)
template<typename F, concepts::TupleLike Tup>
constexpr auto	apply (F &&f, Tup &&tuple) -> decltype(detail::apply_impl(meta::MakeIndexSequence< meta::TupleSize< Tup > > {}, util::forward< F >(f), util::forward< Tup >(tuple)))
template<typename... Args>
constexpr auto	forward_as_tuple (Args &&... args) -> Tuple< Args &&... >
template<typename... Args>
constexpr auto	make_decayed_tuple (Args &&... args)
template<typename... Args>
constexpr auto	make_tuple (Args &&... args)
template<concepts::TupleLike... Tups>
constexpr auto	tuple_cat (Tups &&... tuples)
template<typename F, concepts::TupleLike Tup> requires (detail::TupleForEachValid<F, Tup, meta::MakeIndexSequence<meta::TupleSize<Tup>>>::value)
constexpr void	tuple_for_each (F &&function, Tup &&tuple)
template<typename F, concepts::TupleLike Tup> requires (detail::TupleTransformValid<F, Tup, meta::MakeIndexSequence<meta::TupleSize<Tup>>>::value)
constexpr auto	tuple_transform (F &&function, Tup &&tuple)
template<concepts::TupleLike... Tups>
constexpr auto	tuple_cat (Tups &&... tuples)
template<typename F, concepts::TupleLike Tup> requires (detail::TupleForEachValid<F, Tup, meta::MakeIndexSequence<meta::TupleSize<Tup>>>::value)
constexpr void	tuple_for_each (F &&function, Tup &&tuple)
template<typename F, concepts::TupleLike Tup> requires (detail::TupleForEachValid<F, Tup, meta::MakeIndexSequence<meta::TupleSize<Tup>>>::value)
constexpr void	tuple_for_each_reverse (F &&function, Tup &&tuple)
template<typename F, concepts::TupleLike Tup> requires (detail::TupleTransformValid<F, Tup, meta::MakeIndexSequence<meta::TupleSize<Tup>>>::value)
constexpr auto	tuple_transform (F &&function, Tup &&tuple)
template<size_t index, concepts::VariantLike Var, typename Res = meta::VariantValue<Var, index>>
constexpr auto	get_if (Var &&variant) -> Optional< meta::RemoveRValueReference< Res > >
template<typename R, typename Vis, concepts::VariantLike... Vars, typename Indices = meta::CartesianProduct<meta::AsList<meta::MakeIndexSequence<meta::VariantSize<Vars>>>...>> requires (requires { []<concepts::TypeList... Idx>(meta::List<Idx...>) { return Array { (&detail::VisitHelper<Idx, R, Vis, Vars...>::call)... }; }(Indices {}); })
constexpr auto	visit (Vis &&visitor, Vars &&... variants) -> R

Variables
constexpr auto	signbit = math::detail::Signbit {}
constexpr auto	copysign = math::detail::Copysign {}
constexpr auto	round = math::detail::Round {}
constexpr auto	remainder = math::detail::Remainder {}
constexpr auto	fmod = math::detail::Fmod {}
constexpr auto	cos = math::detail::Cos {}
constexpr auto	sin = math::detail::Sin {}
constexpr auto	approximately_equal = math::detail::ApproximatelyEqual {}
constexpr auto	unsafe_forget = util::detail::UnsafeForget {}
	Steal ownership of an object and do not its destructor.
constexpr auto	as_writable_byte_span = vocab::byte_buffer::AsWritableByteSpan {}
constexpr auto	as_byte_span = vocab::byte_buffer::AsByteSpan {}
constexpr auto	format_error = vocab::detail::FormatError {}
constexpr auto	big_endian_to_host
constexpr auto	host_to_big_endian
constexpr auto	host_to_little_endian
constexpr auto	little_endian_to_host
constexpr auto	bit_ceil
constexpr auto	bit_floor
constexpr auto	bit_width
constexpr auto	byteswap
constexpr auto	countl_one
constexpr auto	countl_zero
constexpr auto	countr_one
constexpr auto	countr_zero
constexpr auto	has_single_bit
constexpr auto	popcount
constexpr auto	rotl
constexpr auto	rotr
template<concepts::InstanceOf< Duration > To>
constexpr auto	duration_cast
template<concepts::InstanceOf< Duration > To>
constexpr auto	time_point_cast
template<typename T>
constexpr auto	get_cli_parser
constexpr auto	sequence
constexpr auto	adjacent_find
constexpr auto	all_of
constexpr auto	any_of
constexpr auto	binary_search
constexpr auto	contains
constexpr auto	contains_subrange
constexpr auto	copy
constexpr auto	copy_backward
constexpr auto	copy_if
constexpr auto	copy_n
constexpr auto	count
constexpr auto	count_if
constexpr auto	destroy
constexpr auto	destroy_n
constexpr auto	ends_with
constexpr auto	equal_range
constexpr auto	fill
constexpr auto	fill_n
constexpr auto	find
constexpr auto	find_end
constexpr auto	find_first_not_of
constexpr auto	find_first_of
constexpr auto	find_if
constexpr auto	find_if_not
constexpr auto	find_last
constexpr auto	find_last_if
constexpr auto	find_last_if_not
constexpr auto	find_last_not_of
constexpr auto	find_last_of
constexpr auto	fold_left
constexpr auto	fold_left_first
constexpr auto	fold_left_first_with_iter
constexpr auto	fold_left_with_iter
constexpr auto	fold_right
constexpr auto	fold_right_last
constexpr auto	for_each
constexpr auto	for_each_n
constexpr auto	is_heap
constexpr auto	is_heap_until
constexpr auto	is_partitioned
constexpr auto	is_permutation
constexpr auto	is_sorted
constexpr auto	is_sorted_until
constexpr auto	lower_bound
constexpr auto	make_heap
constexpr auto	max
constexpr auto	max_element
constexpr auto	merge
constexpr auto	min
constexpr auto	min_element
constexpr auto	minmax
constexpr auto	minmax_element
constexpr auto	mismatch
constexpr auto	next_permutation
constexpr auto	none_of
constexpr auto	partition
constexpr auto	partition_copy
constexpr auto	partition_point
constexpr auto	pop_heap
constexpr auto	prev_permutation
constexpr auto	product
constexpr auto	push_heap
constexpr auto	remove_copy
constexpr auto	remove_copy_if
constexpr auto	replace
constexpr auto	replace_copy
constexpr auto	replace_copy_if
constexpr auto	replace_if
constexpr auto	reverse_copy
constexpr auto	rotate
constexpr auto	rotate_copy
constexpr auto	search
constexpr auto	search_n
constexpr auto	set_difference
constexpr auto	set_intersection
constexpr auto	set_symmetric_difference
constexpr auto	set_union
constexpr auto	shift_left
constexpr auto	shift_right
constexpr auto	shuffle
constexpr auto	sort
constexpr auto	sort_heap
constexpr auto	stable_partition
constexpr auto	starts_with
constexpr auto	sum
constexpr auto	swap_ranges
constexpr auto	uninitialized_copy
constexpr auto	uninitialized_copy_n
constexpr auto	uninitialized_default_construct
constexpr auto	uninitialized_default_construct_n
constexpr auto	uninitialized_fill
constexpr auto	uninitialized_fill_n
constexpr auto	uninitialized_move
constexpr auto	uninitialized_move_n
constexpr auto	uninitialized_relocate
constexpr auto	uninitialized_relocate_backwards
constexpr auto	uninitialized_value_construct
constexpr auto	uninitialized_value_construct_n
constexpr auto	unique
constexpr auto	unique_copy
constexpr auto	upper_bound
constexpr auto	allocate
template<typename T>
constexpr auto	allocate_many
template<typename T>
constexpr auto	allocate_one
constexpr auto	deallocate
template<typename T>
constexpr auto	deallocate_many
template<typename T>
constexpr auto	deallocate_one
constexpr auto	fail_allocator
constexpr auto	hash
constexpr auto	hash_write
constexpr auto	at
constexpr auto	at_unchecked
constexpr auto	back
constexpr auto	back_unchecked
constexpr auto	front
constexpr auto	front_unchecked
constexpr auto	begin
constexpr auto	cbegin
constexpr auto	cdata
constexpr auto	cend
constexpr auto	crbegin
constexpr auto	crend
constexpr auto	data
constexpr auto	empty
constexpr auto	end
constexpr auto	erase
constexpr auto	erase_if
constexpr auto	rbegin
constexpr auto	reconstruct
constexpr auto	rend
constexpr auto	size
constexpr auto	ssize
constexpr auto	advance
constexpr auto	default_sentinel
constexpr auto	distance
constexpr auto	next
constexpr auto	prev
constexpr auto	to_transparent_string
constexpr auto	to_utf8_string
constexpr auto	to_utf8_string_lossy
constexpr auto	from_container
constexpr auto	cache_last
constexpr auto	stopped
constexpr auto	sync_wait
constexpr auto	sync_wait_on
constexpr auto	sync_wait_with_variant
constexpr auto	sync_wait_with_variant_on
constexpr as_awaitable_ns::Function	as_awaitable
template<concepts::InstanceOf< Protocol > Proto>
constexpr auto	ipc_binary_connect_to_client
template<concepts::InstanceOf< Protocol > Proto>
constexpr auto	ipc_binary_connect_to_server
constexpr auto	send
constexpr auto	empty_env
constexpr auto	format
template<concepts::Encoding Enc>
constexpr auto	format_encoded_context
constexpr auto	formatter_in_place
constexpr auto	to_string
constexpr auto	as_bool
constexpr auto	between_exclusive
constexpr auto	between_inclusive
constexpr auto	bit_and
constexpr auto	compare
constexpr auto	compare_backwards
template<concepts::LanguageFunction T, concepts::Allocator Alloc = platform::DefaultAllocator>
constexpr auto	make_function
constexpr auto	curry
constexpr auto	curry_back
constexpr auto	dereference
constexpr auto	equal
constexpr auto	equal_or_greater
constexpr auto	equal_or_less
constexpr auto	greater
constexpr auto	identity
constexpr auto	into_void
constexpr auto	invoke
template<typename R>
constexpr auto	invoke_r
constexpr auto	less
template<typename T>
constexpr auto	make_deferred
	Creates a deferred function object.
constexpr auto	minus
constexpr auto	multiplies
constexpr auto	not_equal
constexpr auto	overload
constexpr auto	plus
constexpr auto	proj
constexpr tag_invoke_detail::TagInvokeFn	tag_invoke
constexpr auto	uncurry
constexpr auto	ycombinator
constexpr auto	read_some
constexpr auto	write_some
constexpr auto	read_all
constexpr auto	read_exactly
constexpr auto	read_to_string
constexpr auto	write_exactly
template<concepts::Encoding Enc>
constexpr auto	writer_print
template<concepts::Encoding Enc>
constexpr auto	writer_println
constexpr auto	abs
constexpr auto	abs_diff
constexpr auto	abs_unsigned
constexpr auto	align_down
constexpr auto	align_up
constexpr auto	divide_round_up
constexpr auto	gcd
template<concepts::Integer T>
constexpr auto	representable_as
template<concepts::Integer T>
constexpr auto	representable_as
constexpr auto	lcm
constexpr auto	midpoint
constexpr auto	to_signed
constexpr auto	to_unsigned
template<auto val>
constexpr auto	c_
	A value of type Constexpr<val>.
template<typename T>
constexpr auto	create_parser
constexpr auto	create_parser_in_place
template<typename T>
constexpr auto	parse
template<typename T>
constexpr auto	parse_partial
template<typename T>
constexpr auto	parse_unchecked
template<typename T>
constexpr auto	parse
template<typename T>
constexpr auto	parse_partial
template<typename T>
constexpr auto	parse_unchecked
constexpr auto	run_parser
constexpr auto	run_parser_partial
constexpr auto	run_parser_unchecked
constexpr auto	run_parser
constexpr auto	run_parser_partial
constexpr auto	run_parser_unchecked
template<typename T>
constexpr auto	atom
constexpr auto	enum_to_string
template<container::FixedString enumerator_name, auto enumerator_value, container::FixedString description = "">
constexpr auto	enumerator
template<container::FixedString enum_name, container::FixedString description = "">
constexpr auto	make_enumerators
template<container::FixedString field_name, auto field_pointer, container::FixedString description = "">
constexpr auto	field
template<container::FixedString class_name, container::FixedString description = "">
constexpr auto	make_fields
constexpr auto	reflect
template<concepts::Reflectable T, typename M = Reflect<T>>
constexpr auto	type_name
constexpr auto	valid_enum_value
template<typename T>
constexpr auto	deserialize_binary
constexpr auto	binary_format
constexpr auto	serialize_binary
template<typename T>
constexpr auto	deserialize
constexpr auto	deserialize_in_place
constexpr auto	deserializer
template<typename T>
constexpr auto	deserialize_string
template<typename T = json::Value>
constexpr auto	deserialize_json
template<concepts::Deserializable< JsonDeserializer< StringReader< container::StringView > > > T = json::Value>
constexpr auto	from_json_string
constexpr auto	json_format
constexpr auto	serialize_json
constexpr auto	to_json_string
constexpr auto	serialize
constexpr auto	serialize_size
constexpr auto	serializer
constexpr auto	serialize_string
constexpr auto	adopt_lock
constexpr auto	defer_lock
constexpr auto	try_to_lock
constexpr auto	in_place
template<template< typename... > typename Template>
constexpr auto	in_place_template
template<typename T>
constexpr auto	in_place_type
constexpr auto	piecewise_construct
constexpr auto	clamp
constexpr auto	clone
template<typename T>
constexpr auto	construct
constexpr auto	construct_at
constexpr auto	create_in_place
constexpr auto	default_construct_at
constexpr auto	destroy_at
constexpr auto	get_in_place
constexpr auto	maybe_clone
template<typename Arg>
constexpr auto	get_named_argument
	A helper function to access a named argument.
template<typename Arg>
constexpr auto	get_named_argument_or
	A helper function to access a named argument or a fallback value.
constexpr auto	cref
constexpr auto	ref
constexpr auto	relocate
constexpr struct di::util::SwapFunction	swap
constexpr auto	to_address
constexpr auto	to_owned
constexpr auto	to_uintptr
constexpr auto	to_underlying
constexpr auto	unwrap_reference
constexpr auto	generate_uuid
constexpr auto	voidify
constexpr auto	into_status_code
constexpr auto	as_fallible
constexpr auto	if_error
constexpr auto	if_success
constexpr auto	invoke_as_fallible
constexpr auto	try_infallible
constexpr auto	unexpect
constexpr auto	lift_bool
constexpr auto	nullopt
template<detail::IntrusivePtrValid< ArcTag > T>
constexpr auto	make_arc
template<typename T>
constexpr auto	make_box
constexpr auto	adopt_object
constexpr auto	retain_object
constexpr auto	adopt_object
template<detail::IntrusivePtrValid< ArcTag > T>
constexpr auto	make_arc
template<typename T>
constexpr auto	make_box
template<detail::IntrusivePtrValid< RcTag > T>
constexpr auto	make_rc
constexpr auto	retain_object
template<detail::IntrusivePtrValid< RcTag > T>
constexpr auto	make_rc
constexpr auto	as_bytes
constexpr auto	as_writable_bytes
constexpr auto	as_bytes
constexpr auto	as_writable_bytes
constexpr auto	dynamic_extent
constexpr auto	dynamic_extent
template<typename T>
constexpr auto	make_from_tuple
template<typename T>
constexpr auto	make_from_tuple
constexpr auto	tie
template<typename R>
constexpr auto	tuple_sequence
constexpr auto	tie
template<typename R>
constexpr auto	tuple_sequence
template<typename T>
constexpr auto	holds_alternative

Typedef Documentation

◆ AllocatorResult

template<concepts::Allocator Alloc, typename T = void>

using di::meta::AllocatorResult

◆ Any

template<concepts::Interface UserInterface, concepts::AnyStorage Storage = HybridStorage<>, typename VTablePolicy = MaybeInlineVTable<3>>

using di::any::Any

◆ AnyHybrid

template<concepts::Interface Interface, StorageCategory storage_category = StorageCategory::MoveOnly, size_t inline_size = 2 * sizeof(void*), size_t inline_align = alignof(void*), concepts::Allocator Alloc = platform::DefaultAllocator>

using di::any::AnyHybrid

◆ AnyInline

template<concepts::Interface Interface, size_t inline_size = 2 * sizeof(void*), size_t inline_align = alignof(void*)>

using di::any::AnyInline

◆ AnyOperationState

template<typename Env = void, concepts::AnyStorage Storage = any::HybridStorage<any::StorageCategory::MoveOnly, 8 * sizeof(void*), alignof(void*)>, typename VTablePolicy = any::MaybeInlineVTable<3>>

using di::execution::AnyOperationState

◆ AnyReceiver

template<concepts::ValidCompletionSignatures Sigs, typename Env = void, concepts::AnyStorage Storage = any::InlineStorage<2 * sizeof(void*), alignof(void*)>, typename VTablePolicy = any::MaybeInlineVTable<3>>

using di::execution::AnyReceiver

◆ AnyRef

template<concepts::Interface Interface>

using di::any::AnyRef

◆ AnySender

template<concepts::ValidCompletionSignatures Sigs, typename Env = void, concepts::AnyStorage Storage = any::HybridStorage<>, typename VTablePolicy = any::MaybeInlineVTable<3>, concepts::OperationState Op = AnyOperationState<>, typename Rec = AnyReceiver<detail::AnySigs<Sigs>>>

using di::execution::AnySender

◆ AnySenderOf

template<typename T = void>

using di::execution::AnySenderOf

◆ AnyShared

template<concepts::Interface Interface, concepts::Allocator Alloc = platform::DefaultAllocator>

using di::any::AnyShared

◆ AnyUnique

template<concepts::Interface Interface, concepts::Allocator Alloc = platform::DefaultAllocator>

using di::any::AnyUnique

◆ Arc [1/2]

template<typename T>

using di::vocab::Arc

◆ Arc [2/2]

template<typename T>

using di::vocab::Arc

◆ AsyncGenerator

template<typename Ref, typename Value = void>

using di::execution::AsyncGenerator

◆ Base64View

using di::Base64View = Base64<di::Span<byte const>>

◆ Byte

using di::types::Byte

◆ byte

using di::types::byte

◆ ByteBuffer

using di::ByteBuffer = vocab::byte_buffer::ByteBufferImpl<>

◆ c16

using di::types::c16

◆ c32

using di::types::c32

◆ c8

using di::types::c8

◆ CallResult

template<typename F, typename... Args>

using di::meta::CallResult

◆ CoroutineHandle

template<typename Promise = void>

using di::CoroutineHandle = std::coroutine_handle<Promise>

◆ CountingScope

template<concepts::Allocator Alloc = platform::DefaultAllocator>

using di::execution::CountingScope

A scope that waits for all spawned senders to complete.

Template Parameters

Alloc The allocator to use for the scope.

CountingScope is a scope that waits for all spawned senders to complete, using the async resource mechanism. This means that it can only be accessed using the execution::use_resources function. The provided token allows spawning work, and the async "destructor" will wait for all spawned work to complete.

This limited API allows the scope to be implemented efficently, with only an atomic counter. This is possible only because the resource API guarantees that we will wait for all spawned work exactly once. More advanced use cases may need to wait multiple times, or store the scope in non-async storage, and would need to use a different scope implementation.

See also: use_resources; nest; spawn; spawn_future; request_stop

◆ Days

using di::chrono::Days

◆ DefaultAllocator

using di::platform::DefaultAllocator

◆ DefaultFallibleAllocator

using di::platform::DefaultFallibleAllocator

◆ DefaultLock

using di::platform::DefaultLock

◆ DeserializeMetadata

template<concepts::DeserializationFormat S, typename T>

using di::meta::DeserializeMetadata

◆ DeserializeResult

template<typename S, typename T>

using di::meta::DeserializeResult

◆ Dextents

template<typename SizeType, usize rank>

using di::vocab::Dextents

◆ Dispatcher

template<typename Self, concepts::LanguageFunction Sig, typename... Tags>

using di::any::Dispatcher

◆ Error

using di::vocab::Error

The error module is nearly an implementation of P1028R4. https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1028r4.pdf

◆ ExclusiveByteBuffer

using di::ExclusiveByteBuffer = vocab::byte_buffer::ExclusiveByteBufferImpl<>

◆ f32

using di::types::f32

◆ f64

using di::types::f64

◆ FormatBackgroundColor

using di::FormatBackgroundColor = fmt::BackgroundColor

◆ FormatColor

using di::FormatColor = fmt::Color

◆ FormatEffect

using di::FormatEffect = fmt::Effect

◆ FormatStringImpl

template<concepts::Encoding Enc, concepts::Formattable... Args>

using di::fmt::FormatStringImpl

◆ GenericCode

using di::vocab::GenericCode

◆ Hours

using di::chrono::Hours

◆ i128_fallback

using di::math::i128_fallback

◆ i16

using di::types::i16

◆ i256

using di::math::i256

◆ i32

using di::types::i32

◆ i64

using di::types::i64

◆ i8

using di::types::i8

◆ imax

using di::types::imax

◆ intptr_t

using di::types::intptr_t

◆ IntrusiveHashSetNode

template<typename Tag>

using di::container::IntrusiveHashSetNode

◆ IntrusiveTreeSetNode

template<typename Tag = DefaultIntrusiveTreeSetTag>

using di::container::IntrusiveTreeSetNode

◆ InvokeResult

template<typename... Ts>

using di::meta::InvokeResult

◆ iptr

using di::types::iptr

◆ isize

using di::types::isize

◆ Microseconds

using di::chrono::Microseconds

◆ Milliseconds

using di::chrono::Milliseconds

◆ MinstdRand

using di::random::MinstdRand

◆ MinstdRand0

using di::random::MinstdRand0

◆ Minutes

using di::chrono::Minutes

◆ Months

using di::chrono::Months

◆ Nanoseconds

using di::chrono::Nanoseconds

◆ NoopCoroutineHandle

using di::NoopCoroutineHandle = std::noop_coroutine_handle

◆ NoopCoroutinePromise

using di::NoopCoroutinePromise = std::noop_coroutine_promise

◆ nullptr_t

using di::types::nullptr_t

◆ Path

using di::container::Path

◆ PathView

using di::container::PathView

◆ PercentEncodedView

using di::PercentEncodedView = PercentEncoded<di::TransparentStringView>

◆ Picoseconds

using di::chrono::Picoseconds