Namespaces
namespace	any

namespace	assert

namespace	bit

namespace	chrono

namespace	chrono_duration_literals

namespace	cli

namespace	concepts

namespace	constexpr_integral_literals

namespace	container

namespace	detail

namespace	exec

namespace	execution

namespace	format

namespace	function

namespace	integral_literals

namespace	integral_set_literals

namespace	io

namespace	json_literals

namespace	literals

namespace	math

namespace	meta

namespace	numbers

namespace	parser

namespace	path_literals

namespace	path_view_literals

namespace	platform

namespace	random

namespace	reflection

namespace	serialization

namespace	string_literals

namespace	string_view_literals

namespace	sync

namespace	types

namespace	util

namespace	uuid_literals

namespace	vocab

Classes
struct	AdoptObject

struct	AllocationResult

struct	Array

struct	AsBool

struct	Atom

class	Atomic

class	AtomicRef

class	Badge

struct	BetweenExclusive

struct	BetweenInclusive

struct	BidirectionalIteratorTag

class	BigEndian

class	BinaryDeserializer
	A deserializer for a simple binary format. More...

struct	BinaryFormat

class	BinarySerializer
	A serializer for a simple binary format. More...

struct	BitAnd

struct	BitEnum

struct	BitField

struct	BitFlag

class	BitSet

class	BitStruct

class	Box

class	Checked

struct	Compare

struct	CompareBackwards

struct	CompletionSignatures

struct	Constexpr
	A wrapper for a constexpr value. More...

struct	ContiguousIteratorTag

struct	Curry

struct	CurryBack

class	DefaultAccessor

struct	DefaultDelete

struct	DefaultHasher

struct	DefaultSentinel

class	DeferConstruct

struct	Dereference

class	DumbSpinlock

class	Duration

struct	ElementsOf

struct	EmptyEnv

struct	Enumerator

struct	Enumerators

struct	Equal

struct	EqualOrGreater

struct	EqualOrLess

class	ErasedString

class	Expected

class	Extents

struct	FailAllocator

struct	FallibleAllocator

struct	Field

struct	Fields

class	FixedSigned
	A fixed-width signed integer. More...

class	FixedString

class	FixedUnsigned
	A fixed-width unsigned integer. More...

class	FormatParseContext

struct	ForwardIteratorTag

struct	FromContainer

class	Function

class	FunctionRef

class	Generator

class	GenericDomain

struct	Greater

class	GuardedReference

struct	Identity

struct	Immovable

struct	InfallibleAllocator

struct	InlineScheduler

struct	InPlace

class	InPlaceStopCallback

class	InPlaceStopSource

class	InPlaceStopToken

struct	InPlaceTemplate

struct	InPlaceType

struct	InputIteratorTag

class	IntrusiveForwardList

class	IntrusiveForwardListNode

struct	IntrusiveForwardListTag

class	IntrusiveHashMultiSet

class	IntrusiveHashSet

struct	IntrusiveHashSetTag

class	IntrusiveList

class	IntrusiveListNode

struct	IntrusiveListTag

class	IntrusivePtr

struct	IntrusiveRefCount

struct	IntrusiveThreadUnsafeRefCount

class	IntrusiveTreeMultiSet

class	IntrusiveTreeSet

struct	IntrusiveTreeSetTag

class	JsonDeserializer
	A deserializer for the JSON format. More...

struct	JsonFormat

class	JsonSerializer

class	JsonSerializerConfig

struct	LayoutLeft

struct	LayoutRight

struct	LayoutStride

class	Lazy

struct	Less

class	LinearCongruentialEngine

class	LinkedList

class	LittleEndian

class	MDSpan

struct	Method

struct	Minus

class	MovableBox

struct	Multiplies

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	NeverStopToken

class	NodeHashMap

class	NodeHashMultiMap

class	NodeHashMultiSet

class	NodeHashSet

struct	NonCopyable

class	NonPropagatingCache

struct	NotEqual

struct	NumericLimits

class	Optional

struct	PiecewiseConstruct

struct	Plus

class	PriorityQueue

struct	Protocol

class	Queue

struct	RandomAccessIteratorTag

struct	Ratio

class	Rational

class	RebindableBox

class	ReferenceWrapper

struct	RetainObject

class	Ring

class	RunLoop

class	ScopedLock

class	ScopeExit

class	ScopeValueChange

struct	SelfPointer

struct	SequenceTag

struct	SetError

struct	SetStopped

struct	SetValue

class	SizeWriter

class	SourceLocation

class	Span

class	Stack

class	StaticRing

class	StaticVector

class	StatusCode

class	StatusCodeDomain

struct	StoreIf

class	StringReader

class	StringWriter

class	StrongInt

class	Styled

class	Synchronized

struct	This

class	TimePoint

class	TreeMap

class	TreeMultiMap

class	TreeMultiSet

class	TreeSet

class	Tuple

class	Unexpected

class	UniformIntDistribution

class	UUID

class	Variant

class	Vector

class	VectorReader

class	VectorWriter

class	View

struct	Void

class	WithAwaitableSenders

Typedefs
using	FormatColor = format::Color

using	FormatBackgroundColor = format::BackgroundColor

using	FormatEffect = format::Effect

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

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

template<container::FixedString string> requires (detail::valid_json_literal<string>())
constexpr auto	operator""_json ()

consteval auto	operator""_uuid (char const *data, usize size) -> util::UUID

template<concepts::Object T>
constexpr auto	cli_parser (StringView 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... 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::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	as_writable_byte_span = vocab::byte_buffer::AsWritableByteSpan {}

constexpr auto	as_byte_span = vocab::byte_buffer::AsByteSpan {}

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	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	formatter_in_place

constexpr auto	present

template<concepts::Encoding Enc>
constexpr auto	present_encoded_context

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>
constexpr auto	enumerator

template<container::FixedString enum_name>
constexpr auto	make_enumerators

template<container::FixedString field_name, auto field_pointer>
constexpr auto	field

template<container::FixedString class_name>
constexpr auto	make_fields

constexpr auto	reflect

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	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

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

◆ 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

typedef container::FallibleAllocator di::platform::DefaultAllocator

◆ DefaultFallibleAllocator

using di::platform::DefaultFallibleAllocator

◆ DefaultLock

typedef iris::Spinlock 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 = format::BackgroundColor

◆ FormatColor

using di::FormatColor = format::Color

◆ FormatEffect

using di::FormatEffect = format::Effect

◆ FormatStringImpl

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

using di::format::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

◆ Picoseconds

using di::chrono::Picoseconds