di::meta Namespace Reference

Namespaces
namespace	detail

Classes
struct	BindBack
struct	BindFront
struct	Constexpr
	A wrapper for a constexpr value. More...
struct	CustomCommonError
struct	CustomCommonReference
struct	CustomCommonReference< A, B, AQual, BQual >
struct	CustomCommonType
struct	CustomCommonType< A, B >
struct	CustomCommonType< chrono::Duration< Rep1, Period1 >, chrono::Duration< Rep2, Period2 > >
struct	CustomCommonType< chrono::TimePoint< Clock, D1 >, chrono::TimePoint< Clock, D2 > >
struct	CustomCommonType< di::container::ConstIteratorImpl< T >, di::container::ConstIteratorImpl< U > >
struct	CustomCommonType< di::container::ConstIteratorImpl< T >, U >
struct	CustomCommonType< U, di::container::ConstIteratorImpl< T > >
class	EnableBorrowedContainer
class	EnableView
struct	Flip
struct	Hashable
struct	IsFunctionTo
struct	List
struct	List< Head, Rest... >
struct	List< T >
struct	List<>
struct	ListV
struct	Not
struct	Projected
struct	Quote
struct	SameAs
struct	TypeConstant
struct	Uncurry

Concepts
concept	UniqueType
concept	Contains
concept	ExactlyOnce

Typedefs
template<concepts::Interface... Interfaces>
using	MergeInterfaces = meta::Unique<meta::Concat<meta::Transform<Interfaces, meta::Quote<meta::Type>>...>>
template<concepts::Method Method>
using	MethodErasedSignature
template<concepts::Method Method>
using	MethodSignature = Method::Signature
template<concepts::Method Method>
using	MethodTag = Method::Tag
template<typename T>
using	BitValue = T::Value
template<concepts::Allocator Alloc, typename T = void>
using	AllocatorResult = meta::LikeExpected<decltype(di::allocate(util::declval<Alloc&>(), 0, 0)), T>
template<concepts::ViewableContainer Con>
using	AsView = decltype(container::view::all(util::declval<Con>()))
template<concepts::Container Con>
using	BorrowedIterator = Conditional<concepts::BorrowedContainer<Con>, ContainerIterator<Con>, container::Dangling>
template<concepts::Container Con>
using	BorrowedView
template<concepts::InputIterator Iter>
using	ConstIterator = Conditional<concepts::ConstantIterator<Iter>, Iter, container::ConstIteratorImpl<Iter>>
template<typename Sent>
using	ConstSentinel = detail::ConstSentinelHelper<Sent>::Type
template<concepts::Container Con>
using	ContainerConstIterator = ConstIterator<ContainerIterator<Con>>
template<concepts::Container Con>
using	ContainerConstReference = IteratorConstReference<ContainerIterator<Con>>
template<typename T>
using	ContainerIterator = decltype(container::begin(util::declval<T&>()))
template<typename T, typename Tag = meta::RemoveCVRef<T>, typename It = ContainerIterator<T>, typename Sent = ContainerSentinel<T>>
using	ContainerIteratorReconstructed
template<typename T>
using	ContainerReference = IteratorReference<ContainerIterator<T>>
template<typename T>
using	ContainerRValue = IteratorRValue<ContainerIterator<T>>
template<typename T>
using	ContainerSentinel = decltype(container::end(util::declval<T&>()))
template<typename T>
using	ContainerSizeType = decltype(container::size(util::declval<T>()))
template<typename T>
using	ContainerSSizeType = IteratorSSizeType<ContainerIterator<T>>
template<typename T>
using	ContainerValue = IteratorValue<ContainerIterator<T>>
template<typename F, concepts::IndirectlyReadable... Its>
using	IndirectResult = InvokeResult<F, meta::IteratorReference<Its>...>
template<typename T>
using	IteratorCategory = decltype(container::iterator_category(types::in_place_type<meta::RemoveCVRef<T>>))
template<concepts::IndirectlyReadable T>
using	IteratorCommonReference = meta::CommonReference<meta::IteratorReference<T>, meta::IteratorValue<T>&>
template<concepts ::IndirectlyReadable Iter>
using	IteratorConstReference = meta::CommonReference<meta::IteratorValue<Iter> const&&, meta::IteratorReference<Iter>>
template<typename It, typename Sent = It>
using	IteratorReconstructed = decltype(container::reconstruct(util::declval<It>(), util::declval<Sent>()))
template<typename T>
using	IteratorReference = decltype(*util::declval<T const&>())
template<typename T>
using	IteratorRValue = decltype(container::iterator_move(util::declval<T&>()))
template<typename T>
using	IteratorSizeType = MakeUnsigned<IteratorSSizeType<T>>
template<typename T>
using	IteratorSSizeType = decltype(container::iterator_ssize_type(types::in_place_type<meta::RemoveCVRef<T>>))
template<typename T>
using	IteratorValue = meta::Type<decltype(container::iterator_value(types::in_place_type<meta::RemoveCVRef<T>>))>
template<typename T, typename It = ContainerIterator<T>, typename Sent = ContainerSentinel<T>>
using	Reconstructed = decltype(container::reconstruct(in_place_type<T>, util::declval<It>(), util::declval<Sent>()))
template<typename T>
using	EncodingCodeUnit = RemoveCVRef<T>::CodeUnit
template<typename T>
using	EncodingCodePoint = RemoveCVRef<T>::CodePoint
template<typename T>
using	EncodingIterator = RemoveCVRef<T>::Iterator
template<concepts::HasEncoding T>
using	Encoding = meta::RemoveCVRef<T>::Encoding
template<typename T>
using	MessageReply = Type<detail::MessageReplyHelper<T>>
template<typename T>
using	Protocol = typename T::Protocol
template<concepts::HasProtocol T>
using	MessageTypesWithoutReplies
template<concepts::HasProtocol T>
using	PeerMessageTypesWithoutReplies
template<concepts::HasProtocol T>
using	MessageTypes = Concat<MessageTypesWithoutReplies<T>, detail::MessagesReplies<PeerMessageTypesWithoutReplies<T>>>
template<concepts::HasProtocol T>
using	AllMessageTypesWithoutReplies = Concat<typename meta::Protocol<T>::Client, typename meta::Protocol<T>::Server>
template<typename Awaitable, typename Promise = void>
using	AwaitResult
template<typename Sender, typename Env = types::EmptyEnv>
using	CompletionSignaturesOf
template<typename Send, typename Rec>
using	ConnectResult = decltype(execution::connect(util::declval<Send>(), util::declval<Rec>()))
template<typename... Types>
using	DecayedTuple = vocab::Tuple<meta::Decay<Types>...>
template<typename T>
using	EnvOf = decltype(execution::get_env(util::declval<T>()))
template<typename Sender, typename Env = types::EmptyEnv, template< typename... > typename Var = meta::VariantOrEmpty>
using	ErrorTypesOf = GatherSignatures<execution::SetError, Sender, Env, meta::TypeIdentity, Var>
template<concepts::ExecutionContext Context>
using	ExecutionContextScheduler = decltype(util::declval<Context&>().get_scheduler())
template<typename Tag, typename S, typename E, template< typename... > typename Tuple, template< typename... > typename Variant>
using	GatherSignatures
template<typename Send, typename Env = types::EmptyEnv, concepts::ValidCompletionSignatures ExtraSigs = types::CompletionSignatures<>, template< typename... > typename SetValue = detail::DefaultSetValue, template< typename... > typename SetError = detail::DefaultSetError, concepts::ValidCompletionSignatures SetStopped = types::CompletionSignatures<execution::SetStopped()>>
using	MakeCompletionSignatures
template<typename Sched>
using	ScheduleResult = decltype(execution::schedule(util::declval<Sched>()))
template<typename Send, typename Env>
using	SingleSenderValueType
template<typename T>
using	StopTokenOf = meta::RemoveCVRef<decltype(execution::get_stop_token(util::declval<T>()))>
template<typename Sender, typename Env = types::EmptyEnv, template< typename... > typename Tup = meta::DecayedTuple, template< typename... > typename Var = meta::VariantOrEmpty>
using	ValueTypesOf = GatherSignatures<execution::SetValue, Sender, Env, Tup, Var>
template<typename... Types>
using	VariantOrEmpty = detail::VariantOrEmptyHelper<meta::Unique<meta::List<Types...>>>::Type
template<typename T>
using	AllocatorOf = meta::RemoveCVRef<decltype(execution::get_allocator(util::declval<T>()))>
template<concepts::Sender Seq>
using	IntoLockstepSequence = decltype(execution::into_lockstep_sequence(util::declval<Seq>()))
	Deduce the type of converting a sequence into a lockstep sequence.
template<typename Rec, typename Send>
using	NextSenderOf = decltype(execution::set_next(util::declval<meta::RemoveCVRef<Rec>&>(), util::declval<Send>()))
template<typename Send, typename Env>
using	SequenceCompletionSignaturesOf
template<typename Send, typename Rec>
using	SubscribeResult = decltype(execution::subscribe(util::declval<Send>(), util::declval<Rec>()))
template<typename... Ts>
using	InvokeResult = decltype(function::detail::invoke_impl(util::declval<Ts>()...))
template<typename Tag, typename... Args>
using	TagInvokeResult = decltype(di::function::tag_invoke(util::declval<Tag>(), util::declval<Args>()...))
template<typename T, concepts::Impl< io::Reader > Reader>
using	ReaderResult
template<typename T, concepts::Impl< io::Writer > Writer>
using	WriterResult
template<typename R, concepts::TypeList T>
using	AsLanguageFunction = Type<detail::AsLanguageFunction<R, T>>
template<typename T>
using	AsList = Type<detail::AsListHelper<T>>
template<template< typename... > typename Template, concepts::TypeList T>
using	AsTemplate = Type<detail::AsTemplateHelper<Template, T>>
template<concepts::TypeList T>
using	AsTuple = AsTemplate<vocab::Tuple, T>
template<concepts::TypeList... Lists>
using	Concat = Type<detail::ConcatHelper<Lists...>>
template<concepts::TypeList L, typename T>
using	PushFront = Concat<List<T>, L>
template<concepts::TypeList L, typename T>
using	PushBack = Concat<L, List<T>>
template<concepts::TypeList List>
using	Join = Apply<Quote<Concat>, List>
template<concepts::TypeList L>
using	PopFront = Type<detail::PopFrontHelper<L>>
template<concepts::TypeList L>
using	PopBack = Type<detail::PopBackHelper<L>>
template<concepts::TypeList List, typename Init, concepts::MetaInvocable MetaFn>
using	Fold = Type<detail::FoldHelper<List, Init, MetaFn>>
template<concepts::TypeList List, typename Init, concepts::MetaInvocable MetaFn>
using	FoldRight = Type<detail::FoldRightHelper<List, Init, MetaFn>>
template<concepts::TypeList List, concepts::MetaInvocable Pred>
using	Filter = Fold<List, meta::List<>, detail::FilterReducer<Pred>>
template<concepts::TypeList List, typename Needle, typename Replacement>
using	Replace = Fold<List, meta::List<>, detail::ReplaceReducer<Needle, Replacement>>
template<concepts::TypeList List, concepts::MetaInvocable Pred, typename Replacement>
using	ReplaceIf = Fold<List, meta::List<>, detail::ReplaceIfReducer<Pred, Replacement>>
template<concepts::TypeList List, typename Function>
using	Transform = detail::TransformHelper<List, Function>::Type
template<concepts::TypeList Lst>
using	Unique = Fold<Lst, List<>, detail::PushBackIfUnique>
template<concepts::TypeList T, concepts::TypeList U>
using	Zip = Type<detail::ZipHelper<T, U>>
template<typename T, usize N>
using	Repeat = Type<detail::RepeatHelper<T, N>>
template<concepts::TypeList... Types>
using	CartesianProduct = Type<detail::CartesianProductHelper<Types...>>
template<typename T, usize count>
using	MakeIntegerSequence = Type<detail::MakeIntegerSequenceHelper<T, count>>
template<usize count>
using	MakeIndexSequence = MakeIntegerSequence<usize, count>
template<typename... Types>
using	IndexSequenceFor = MakeIndexSequence<sizeof...(Types)>
template<typename F, typename... Args>
using	CallResult = decltype(util::declval<F>()(util::declval<Args>()...))
template<typename... Types>
using	CommonType = detail::CommonTypeHelper<Types...>::Type
template<typename... Types>
using	CommonReference = detail::CommonReferenceHelper<Types...>::Type
template<typename... Types>
using	CommonComparisonCategory = Type<detail::CommonComparisonCategoryHelper<Types...>>
template<typename T, typename U = T>
using	CompareThreeWayResult = meta::Type<detail::CompareThreeWayResultHelper<T, U>>
template<concepts::Trait T>
using	Type = T::Type
template<typename T>
using	TypeIdentity = Type<TypeConstant<T>>
	This is a helper template to prevent C++ from deducing the type of template argument.
template<typename T>
using	RemoveConst = Type<detail::RemoveConstHelper<T>>
template<typename T>
using	RemoveVolatile = Type<detail::RemoveVolatile<T>>
template<typename T>
using	RemoveCV = RemoveConst<RemoveVolatile<T>>
template<typename T>
using	RemoveReference = Type<detail::RemoveReferenceHelper<T>>
template<typename T>
using	RemoveCVRef = RemoveCV<RemoveReference<T>>
template<bool value, typename T, typename U>
using	Conditional = detail::ConditionalHelper<value, T, U>::Type
template<template< typename... > typename Fun, typename... Args>
using	Defer = detail::DeferHelper<Fun, Args...>
template<concepts::MetaInvocable Fun, typename... Args>
using	Invoke = Type<Defer<Fun::template Invoke, Args...>>
template<concepts::MetaInvocable F, concepts::TypeList T>
using	Apply = Type<detail::ApplyHelper<F, T>>
template<concepts::MetaInvocable... Funs>
using	Compose = detail::ComposeHelper<Funs...>
template<concepts::MetaInvocable... Funs>
using	Chain = detail::ChainHelper<Funs...>
template<concepts::LanguageFunction Fun>
using	LanguageFunctionReturn = Type<detail::LanguageFunctionReturnHelper<Fun>>
template<typename T>
using	RemoveExtent = Type<detail::RemoveExtentHelper<T>>
template<typename T>
using	RemoveAllExtents = Type<detail::RemoveAllExtentsHelper<T>>
template<concepts::MemberPointer T>
using	MemberPointerValue = Type<detail::MemberPointerValueHelper<RemoveCV<T>>>
template<concepts::MemberPointer T>
using	MemberPointerClass = Type<detail::MemberPointerClassHelper<RemoveCV<T>>>
template<concepts::Enum T>
using	UnderlyingType = __underlying_type(T)
template<typename T>
using	MakeSigned = detail::MakeSignedHelper<RemoveCV<T>>::Type
template<typename T>
using	MakeUnsigned = detail::MakeUnsignedHelper<RemoveCV<T>>::Type
template<typename T>
using	AddConst = T const
template<typename T>
using	AddVolatile = T volatile
template<typename T>
using	AddCV = T const volatile
template<typename T>
using	AddLValueReference = Type<detail::AddLValueReferenceHelper<T>>
template<typename T>
using	AddRValueReference = Type<detail::AddRValueReferenceHelper<T>>
template<typename T>
using	AddPointer = Type<detail::AddPointerHelper<T>>
	This is a helper template which will convert reference types into their corresponding pointer type, while also working for non-references.
template<typename T, typename U>
using	Like = Type<detail::LikeHelper<T, U>>
template<typename T>
using	RemoveRValueReference = Conditional<concepts::RValueReference<T>, RemoveReference<T>, T>
template<typename T>
using	RemovePointer = Type<detail::RemovePointerHelper<T>>
template<typename T>
using	RemoveFunctionQualifiers = Type<detail::RemoveFunctionQualifiersHelper<T>>
template<typename T>
using	Decay
template<concepts::TypeList T>
using	Front = T::Front
template<concepts::TypeList T>
using	Back = T::Back
template<concepts::TypeList T, usize index>
using	At = typename T::template At<index>
template<bool is_const, typename T>
using	MaybeConst = Conditional<is_const, T const, T>
template<concepts::Expected T>
using	ExpectedValue = meta::RemoveCVRef<T>::Value
template<concepts::Expected T>
using	ExpectedError = meta::RemoveCVRef<T>::Error
template<typename T, typename U>
using	LikeExpected = Type<detail::LikeExpectedHelper<T, U>>
template<typename T>
using	UnwrapExpected = Invoke<Conditional<concepts::Expected<T>, meta::Quote<ExpectedValue>, meta::TypeConstant<T>>, T>
template<concepts::Optional T>
using	OptionalValue = meta::RemoveCVRef<T>::Value
template<typename T>
using	WrapReference = detail::WrapReference<T>::Type
template<typename T>
using	UnwrapReference = detail::UnwrapReferenceHelper<T>::Type
template<typename T>
using	UnwrapRefDecay = UnwrapReference<Decay<T>>
template<typename T>
using	UnwrapRefRValue = RemoveRValueReference<UnwrapReference<T>>
template<concepts::IntoParserContext T>
using	AsParserContext = decltype(parser::into_parser_context(util::declval<T>()))
template<concepts::ParserContext Context>
using	ParserContextError = Context::Error
template<typename T, concepts::ParserContext Context>
using	ParserContextResult = vocab::Expected<T, meta::ParserContextError<Context>>
template<concepts::ParserContext Context, concepts::Parser< Context > Parser>
using	ParserValue = meta::ExpectedValue<decltype(util::declval<Parser&>().parse(util::declval<Context&>()))>
template<concepts::Reflectable T>
using	Reflect = decltype(reflection::reflect(in_place_type<T>))
template<concepts::Deserializer S>
using	DeserializationFormat = typename meta::RemoveCVRef<S>::DeserializationFormat
template<typename T, typename Reader = any::AnyRef<io::Reader>, typename... Args>
using	Deserializer
template<typename S, typename T>
using	DeserializeResult = meta::LikeExpected<meta::ReaderResult<void, decltype(util::declval<S>().reader())>, T>
template<concepts::DeserializationFormat S, typename T>
using	DeserializeMetadata = decltype(serialization::deserialize_metadata(in_place_type<T>, in_place_type<S>))
template<concepts::Serializer S>
using	SerializationFormat = typename meta::RemoveCVRef<S>::SerializationFormat
template<typename T, typename Writer = any::AnyRef<io::Writer>, typename... Args>
using	Serializer
template<typename S>
using	SerializeResult = meta::WriterResult<void, decltype(util::declval<S>().writer())>
template<concepts::SerializationFormat S, typename T>
using	SerializeMetadata = decltype(serialization::serialize_metadata(in_place_type<T>, in_place_type<S>))
template<template< typename... > typename Template, typename... Args>
using	DeduceCreate = decltype(util::deduce_create(in_place_template<Template>, util::declval<Args>()...))
template<typename Args, typename Tag>
using	NamedArgument = decltype(util::get_named_argument<Tag>(declval<Args>()))
	A metafunction to the type of a named argument.
template<typename Args, typename Tag>
using	NamedArgumentValue = meta::Decay<NamedArgument<Args, Tag>>
	A metafunction to get the value type of a named argument.
template<typename Args, typename Tag, typename Fallback>
using	NamedArgumentOr = decltype(util::get_named_argument_or<Tag>(declval<Args>(), declval<Fallback>()))
	A metafunction to get the type of a named argument with fallback.
template<typename Args, typename Tag, typename Fallback>
using	NamedArgumentValueOr = meta::Decay<NamedArgumentOr<Args, Tag, Fallback>>
	A metafunction to get the value type of a named argument with fallback.
template<typename... Types>
using	CommonError = detail::CommonErrorHelper<Types...>::Type
template<typename T>
using	StatusCodeDomain = detail::StatusCodeDomainHelper<T>::Type
template<typename T>
using	StatusCodeDomainValue = detail::StatusCodeDomainValueHelper<T>::Type
template<typename T, types::size_t index>
using	TupleElement = decltype(vocab::tuple_element(types::in_place_type<meta::RemoveReference<T>>, c_<index>))::Type
template<concepts::TupleLike Tup>
using	TupleElements
template<concepts::TupleLike Tup, types::size_t index>
using	TupleValue = decltype(util::get<index>(util::declval<Tup>()))
template<typename T, size_t index>
using	VariantAlternative = decltype(vocab::variant_alternative(in_place_type<meta::RemoveReference<T>>, c_<index>))
template<typename T>
using	VariantTypes = decltype(vocab::variant_types(in_place_type<meta::RemoveCVRef<T>>))
template<concepts::VariantLike Var, size_t index>
using	VariantValue = decltype(util::get<index>(util::declval<Var>()))

Variables
template<typename A, typename B>
constexpr bool	matching_sig = false
template<typename T, typename... A, typename U, typename... B>
constexpr bool	matching_sig< T(A...), U(B...)> = concepts::SameAs<T(A&&...), U(B&&...)>
template<typename Sender, typename Env = types::EmptyEnv>
constexpr bool	sends_stopped
template<typename Sequence>
constexpr auto	SequenceCardinality
	Gets the cardinality of a sequence.
template<concepts::TypeList List, concepts::MetaInvocable Pred>
constexpr bool	All = detail::AllHelper<Pred, List>::value
template<auto val>
constexpr auto	c_ = Constexpr<val> {}
	A value of type Constexpr<val>.
template<typename T>
constexpr auto	ArrayRank = 0ZU
template<typename T>
constexpr auto	ArrayRank< T[]> = 1 + ArrayRank<T>
template<typename T, usize N>
constexpr auto	ArrayRank< T[N]> = 1 + ArrayRank<T>
template<typename T, types::size_t level = 0>
constexpr auto	Extent = 0ZU
template<typename T, usize level>
constexpr auto	Extent< T[], level > = Extent<T, level - 1>
template<typename T, usize size>
constexpr auto	Extent< T[size], 0 > = size
template<typename T, usize size, usize level>
constexpr auto	Extent< T[size], level > = Extent<T, level - 1>
template<concepts::TypeList T>
constexpr usize	Size = T::size
template<typename T>
constexpr auto	ExpectedRank = 0ZU
template<concepts::Expected T>
constexpr auto	ExpectedRank< T > = 1 + ExpectedRank<ExpectedValue<T>>
template<typename T>
constexpr auto	OptionalRank = 0ZU
template<concepts::Optional T>
constexpr auto	OptionalRank< T > = 1 + OptionalRank<OptionalValue<T>>
template<typename T>
constexpr auto	TupleSize = vocab::tuple_size(types::in_place_type<meta::RemoveCVRef<T>>)
template<typename T>
constexpr auto	VariantSize = vocab::variant_size(in_place_type<meta::RemoveCVRef<T>>)

Typedef Documentation

AddConst

template<typename T>

using di::meta::AddConst = T const

AddCV

template<typename T>

using di::meta::AddCV = T const volatile

AddLValueReference

template<typename T>

using di::meta::AddLValueReference = Type<detail::AddLValueReferenceHelper<T>>

AddPointer

template<typename T>

using di::meta::AddPointer = Type<detail::AddPointerHelper<T>>

This is a helper template which will convert reference types into their corresponding pointer type, while also working for non-references.

For types which cannot be made into a pointer (function types), this does nothing.

AddRValueReference

template<typename T>

using di::meta::AddRValueReference = Type<detail::AddRValueReferenceHelper<T>>

AddVolatile

template<typename T>

using di::meta::AddVolatile = T volatile

AllMessageTypesWithoutReplies

template<concepts::HasProtocol T>

using di::meta::AllMessageTypesWithoutReplies = Concat<typename meta::Protocol<T>::Client, typename meta::Protocol<T>::Server>

AllocatorOf

template<typename T>

using di::meta::AllocatorOf = meta::RemoveCVRef<decltype(execution::get_allocator(util::declval<T>()))>

AllocatorResult

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

using di::meta::AllocatorResult = meta::LikeExpected<decltype(di::allocate(util::declval<Alloc&>(), 0, 0)), T>

Apply

template<concepts::MetaInvocable F, concepts::TypeList T>

using di::meta::Apply = Type<detail::ApplyHelper<F, T>>

AsLanguageFunction

template<typename R, concepts::TypeList T>

using di::meta::AsLanguageFunction = Type<detail::AsLanguageFunction<R, T>>

AsList

template<typename T>

using di::meta::AsList = Type<detail::AsListHelper<T>>

AsParserContext

template<concepts::IntoParserContext T>

using di::meta::AsParserContext = decltype(parser::into_parser_context(util::declval<T>()))

AsTemplate

template<template< typename... > typename Template, concepts::TypeList T>

using di::meta::AsTemplate = Type<detail::AsTemplateHelper<Template, T>>

AsTuple

template<concepts::TypeList T>

using di::meta::AsTuple = AsTemplate<vocab::Tuple, T>

AsView

template<concepts::ViewableContainer Con>

using di::meta::AsView = decltype(container::view::all(util::declval<Con>()))

At

template<concepts::TypeList T, usize index>

using di::meta::At = typename T::template At<index>

AwaitResult

template<typename Awaitable, typename Promise = void>

using di::meta::AwaitResult

Initial value:

 
    decltype(concepts::detail::get_awaiter(util::declval<Awaitable>(), util::declval<Promise*>()).await_resume())

Back

template<concepts::TypeList T>

using di::meta::Back = T::Back

BitValue

template<typename T>

using di::meta::BitValue = T::Value

BorrowedIterator

template<concepts::Container Con>

using di::meta::BorrowedIterator = Conditional<concepts::BorrowedContainer<Con>, ContainerIterator<Con>, container::Dangling>

BorrowedView

template<concepts::Container Con>

using di::meta::BorrowedView

Initial value:

 
    Conditional<concepts::BorrowedContainer<Con>, container::View<ContainerIterator<Con>>, container::Dangling>

CallResult

template<typename F, typename... Args>

using di::meta::CallResult = decltype(util::declval<F>()(util::declval<Args>()...))

CartesianProduct

template<concepts::TypeList... Types>

using di::meta::CartesianProduct = Type<detail::CartesianProductHelper<Types...>>

Chain

template<concepts::MetaInvocable... Funs>

using di::meta::Chain = detail::ChainHelper<Funs...>

CommonComparisonCategory

template<typename... Types>

using di::meta::CommonComparisonCategory = Type<detail::CommonComparisonCategoryHelper<Types...>>

CommonError

template<typename... Types>

using di::meta::CommonError = detail::CommonErrorHelper<Types...>::Type

CommonReference

template<typename... Types>

using di::meta::CommonReference = detail::CommonReferenceHelper<Types...>::Type

CommonType

template<typename... Types>

using di::meta::CommonType = detail::CommonTypeHelper<Types...>::Type

CompareThreeWayResult

template<typename T, typename U = T>

using di::meta::CompareThreeWayResult = meta::Type<detail::CompareThreeWayResultHelper<T, U>>

CompletionSignaturesOf

template<typename Sender, typename Env = types::EmptyEnv>

using di::meta::CompletionSignaturesOf

Initial value:

 
    decltype(execution::get_completion_signatures(util::declval<Sender>(), util::declval<Env>()))

Compose

template<concepts::MetaInvocable... Funs>

using di::meta::Compose = detail::ComposeHelper<Funs...>

Concat

template<concepts::TypeList... Lists>

using di::meta::Concat = Type<detail::ConcatHelper<Lists...>>

Conditional

template<bool value, typename T, typename U>

using di::meta::Conditional = detail::ConditionalHelper<value, T, U>::Type

ConnectResult

template<typename Send, typename Rec>

using di::meta::ConnectResult = decltype(execution::connect(util::declval<Send>(), util::declval<Rec>()))

ConstIterator

template<concepts::InputIterator Iter>

using di::meta::ConstIterator = Conditional<concepts::ConstantIterator<Iter>, Iter, container::ConstIteratorImpl<Iter>>

ConstSentinel

template<typename Sent>

using di::meta::ConstSentinel = detail::ConstSentinelHelper<Sent>::Type

ContainerConstIterator

template<concepts::Container Con>

using di::meta::ContainerConstIterator = ConstIterator<ContainerIterator<Con>>

ContainerConstReference

template<concepts::Container Con>

using di::meta::ContainerConstReference = IteratorConstReference<ContainerIterator<Con>>

ContainerIterator

template<typename T>

using di::meta::ContainerIterator = decltype(container::begin(util::declval<T&>()))

ContainerIteratorReconstructed

template<typename T, typename Tag = meta::RemoveCVRef<T>, typename It = ContainerIterator<T>, typename Sent = ContainerSentinel<T>>

using di::meta::ContainerIteratorReconstructed

Initial value:

 
    decltype(container::reconstruct(in_place_type<Tag>, util::declval<T>, util::declval<It>(), util::declval<Sent>()))

ContainerReference

template<typename T>

using di::meta::ContainerReference = IteratorReference<ContainerIterator<T>>

ContainerRValue

template<typename T>

using di::meta::ContainerRValue = IteratorRValue<ContainerIterator<T>>

ContainerSentinel

template<typename T>

using di::meta::ContainerSentinel = decltype(container::end(util::declval<T&>()))

ContainerSizeType

template<typename T>

using di::meta::ContainerSizeType = decltype(container::size(util::declval<T>()))

ContainerSSizeType

template<typename T>

using di::meta::ContainerSSizeType = IteratorSSizeType<ContainerIterator<T>>

ContainerValue

template<typename T>

using di::meta::ContainerValue = IteratorValue<ContainerIterator<T>>

Decay

template<typename T>

using di::meta::Decay

Initial value:

 Conditional<
    concepts::LanguageArray<RemoveReference<T>>, RemoveExtent<RemoveReference<T>>*,
    Conditional<concepts::LanguageFunction<RemoveReference<T>>, AddPointer<RemoveReference<T>>, RemoveCVRef<T>>>

DecayedTuple

template<typename... Types>

using di::meta::DecayedTuple = vocab::Tuple<meta::Decay<Types>...>

DeduceCreate

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

using di::meta::DeduceCreate = decltype(util::deduce_create(in_place_template<Template>, util::declval<Args>()...))

Defer

template<template< typename... > typename Fun, typename... Args>

using di::meta::Defer = detail::DeferHelper<Fun, Args...>

DeserializationFormat

template<concepts::Deserializer S>

using di::meta::DeserializationFormat = typename meta::RemoveCVRef<S>::DeserializationFormat

DeserializeMetadata

template<concepts::DeserializationFormat S, typename T>

using di::meta::DeserializeMetadata = decltype(serialization::deserialize_metadata(in_place_type<T>, in_place_type<S>))

Deserializer

template<typename T, typename Reader = any::AnyRef<io::Reader>, typename... Args>

using di::meta::Deserializer

Initial value:

 
    decltype(serialization::deserializer(util::declval<T>(), util::declval<Reader>(), util::declval<Args>()...))

DeserializeResult

template<typename S, typename T>

using di::meta::DeserializeResult = meta::LikeExpected<meta::ReaderResult<void, decltype(util::declval<S>().reader())>, T>

Encoding

template<concepts::HasEncoding T>

using di::meta::Encoding = meta::RemoveCVRef<T>::Encoding

EncodingCodePoint

template<typename T>

using di::meta::EncodingCodePoint = RemoveCVRef<T>::CodePoint

EncodingCodeUnit

template<typename T>

using di::meta::EncodingCodeUnit = RemoveCVRef<T>::CodeUnit

EncodingIterator

template<typename T>

using di::meta::EncodingIterator = RemoveCVRef<T>::Iterator

EnvOf

template<typename T>

using di::meta::EnvOf = decltype(execution::get_env(util::declval<T>()))

ErrorTypesOf

template<typename Sender, typename Env = types::EmptyEnv, template< typename... > typename Var = meta::VariantOrEmpty>

using di::meta::ErrorTypesOf = GatherSignatures<execution::SetError, Sender, Env, meta::TypeIdentity, Var>

ExecutionContextScheduler

template<concepts::ExecutionContext Context>

using di::meta::ExecutionContextScheduler = decltype(util::declval<Context&>().get_scheduler())

ExpectedError

template<concepts::Expected T>

using di::meta::ExpectedError = meta::RemoveCVRef<T>::Error

ExpectedValue

template<concepts::Expected T>

using di::meta::ExpectedValue = meta::RemoveCVRef<T>::Value

Filter

template<concepts::TypeList List, concepts::MetaInvocable Pred>

using di::meta::Filter = Fold<List, meta::List<>, detail::FilterReducer<Pred>>

Fold

template<concepts::TypeList List, typename Init, concepts::MetaInvocable MetaFn>

using di::meta::Fold = Type<detail::FoldHelper<List, Init, MetaFn>>

FoldRight

template<concepts::TypeList List, typename Init, concepts::MetaInvocable MetaFn>

using di::meta::FoldRight = Type<detail::FoldRightHelper<List, Init, MetaFn>>

Front

template<concepts::TypeList T>

using di::meta::Front = T::Front

GatherSignatures

template<typename Tag, typename S, typename E, template< typename... > typename Tuple, template< typename... > typename Variant>

using di::meta::GatherSignatures

Initial value:

 meta::Type<detail::MetaApply<
    Variant, meta::Type<detail::GatherSignaturesHelper<Tag, meta::AsList<meta::CompletionSignaturesOf<S, E>>, Tuple>>>>

IndexSequenceFor

template<typename... Types>

using di::meta::IndexSequenceFor = MakeIndexSequence<sizeof...(Types)>

IndirectResult

template<typename F, concepts::IndirectlyReadable... Its>

using di::meta::IndirectResult = InvokeResult<F, meta::IteratorReference<Its>...>

IntoLockstepSequence

template<concepts::Sender Seq>

using di::meta::IntoLockstepSequence = decltype(execution::into_lockstep_sequence(util::declval<Seq>()))

Deduce the type of converting a sequence into a lockstep sequence.

Template Parameters

Seq	The sequence to convert.

See also

execution::into_lockstep_sequence

Invoke

template<concepts::MetaInvocable Fun, typename... Args>

using di::meta::Invoke = Type<Defer<Fun::template Invoke, Args...>>

InvokeResult

template<typename... Ts>

using di::meta::InvokeResult = decltype(function::detail::invoke_impl(util::declval<Ts>()...))

IteratorCategory

template<typename T>

using di::meta::IteratorCategory = decltype(container::iterator_category(types::in_place_type<meta::RemoveCVRef<T>>))

IteratorCommonReference

template<concepts::IndirectlyReadable T>

using di::meta::IteratorCommonReference = meta::CommonReference<meta::IteratorReference<T>, meta::IteratorValue<T>&>

IteratorConstReference

template<concepts ::IndirectlyReadable Iter>

using di::meta::IteratorConstReference = meta::CommonReference<meta::IteratorValue<Iter> const&&, meta::IteratorReference<Iter>>

IteratorReconstructed

template<typename It, typename Sent = It>

using di::meta::IteratorReconstructed = decltype(container::reconstruct(util::declval<It>(), util::declval<Sent>()))

IteratorReference

template<typename T>

using di::meta::IteratorReference = decltype(*util::declval<T const&>())

IteratorRValue

template<typename T>

using di::meta::IteratorRValue = decltype(container::iterator_move(util::declval<T&>()))

IteratorSizeType

template<typename T>

using di::meta::IteratorSizeType = MakeUnsigned<IteratorSSizeType<T>>

IteratorSSizeType

template<typename T>

using di::meta::IteratorSSizeType = decltype(container::iterator_ssize_type(types::in_place_type<meta::RemoveCVRef<T>>))

IteratorValue

template<typename T>

using di::meta::IteratorValue = meta::Type<decltype(container::iterator_value(types::in_place_type<meta::RemoveCVRef<T>>))>

Join

template<concepts::TypeList List>

using di::meta::Join = Apply<Quote<Concat>, List>

LanguageFunctionReturn

template<concepts::LanguageFunction Fun>

using di::meta::LanguageFunctionReturn = Type<detail::LanguageFunctionReturnHelper<Fun>>

Like

template<typename T, typename U>

using di::meta::Like = Type<detail::LikeHelper<T, U>>

LikeExpected

template<typename T, typename U>

using di::meta::LikeExpected = Type<detail::LikeExpectedHelper<T, U>>

MakeCompletionSignatures

template<typename Send, typename Env = types::EmptyEnv, concepts::ValidCompletionSignatures ExtraSigs = types::CompletionSignatures<>, template< typename... > typename SetValue = detail::DefaultSetValue, template< typename... > typename SetError = detail::DefaultSetError, concepts::ValidCompletionSignatures SetStopped = types::CompletionSignatures<execution::SetStopped()>>

using di::meta::MakeCompletionSignatures

Initial value:

 Type<detail::MakeCompletionSignaturesHelper<
    ExtraSigs, meta::ValueTypesOf<Send, Env, SetValue, meta::List>,
    meta::Transform<meta::ErrorTypesOf<Send, Env, meta::List>, meta::Quote<SetError>>,
    meta::Conditional<meta::sends_stopped<Send, Env>, SetStopped, types::CompletionSignatures<>>>>

MakeIndexSequence

template<usize count>

using di::meta::MakeIndexSequence = MakeIntegerSequence<usize, count>

MakeIntegerSequence

template<typename T, usize count>

using di::meta::MakeIntegerSequence = Type<detail::MakeIntegerSequenceHelper<T, count>>

MakeSigned

template<typename T>

using di::meta::MakeSigned = detail::MakeSignedHelper<RemoveCV<T>>::Type

MakeUnsigned

template<typename T>

using di::meta::MakeUnsigned = detail::MakeUnsignedHelper<RemoveCV<T>>::Type

MaybeConst

template<bool is_const, typename T>

using di::meta::MaybeConst = Conditional<is_const, T const, T>

MemberPointerClass

template<concepts::MemberPointer T>

using di::meta::MemberPointerClass = Type<detail::MemberPointerClassHelper<RemoveCV<T>>>

MemberPointerValue

template<concepts::MemberPointer T>

using di::meta::MemberPointerValue = Type<detail::MemberPointerValueHelper<RemoveCV<T>>>

MergeInterfaces

template<concepts::Interface... Interfaces>

using di::meta::MergeInterfaces = meta::Unique<meta::Concat<meta::Transform<Interfaces, meta::Quote<meta::Type>>...>>

MessageReply

template<typename T>

using di::meta::MessageReply = Type<detail::MessageReplyHelper<T>>

MessageTypes

template<concepts::HasProtocol T>

using di::meta::MessageTypes = Concat<MessageTypesWithoutReplies<T>, detail::MessagesReplies<PeerMessageTypesWithoutReplies<T>>>

MessageTypesWithoutReplies

template<concepts::HasProtocol T>

using di::meta::MessageTypesWithoutReplies

Initial value:

 
    Conditional<is_client<T>, typename meta::Protocol<T>::Client,
                Conditional<is_server<T>, typename meta::Protocol<T>::Server, detail::MustBeClientOrServer>>

MethodErasedSignature

template<concepts::Method Method>

using di::meta::MethodErasedSignature

Initial value:

 
    meta::AsLanguageFunction<meta::LanguageFunctionReturn<meta::MethodSignature<Method>>,
                             meta::ReplaceIf<meta::AsList<meta::MethodSignature<Method>>,
                                             meta::Compose<meta::SameAs<This>, meta::Quote<meta::RemoveCVRef>>, void*>>

MethodSignature

template<concepts::Method Method>

using di::meta::MethodSignature = Method::Signature

MethodTag

template<concepts::Method Method>

using di::meta::MethodTag = Method::Tag

NamedArgument

template<typename Args, typename Tag>

using di::meta::NamedArgument = decltype(util::get_named_argument<Tag>(declval<Args>()))

A metafunction to the type of a named argument.

Template Parameters

Args	The type of the named argument.
Tag	The type of the named argument.

This metafunction returns the value type of a named argument in a list of named arguments. If the named argument is not present, this will be a compile-time error.

See also

NamedArguments

NamedArgumentOr

template<typename Args, typename Tag, typename Fallback>

using di::meta::NamedArgumentOr = decltype(util::get_named_argument_or<Tag>(declval<Args>(), declval<Fallback>()))

A metafunction to get the type of a named argument with fallback.

Template Parameters

Args	The type of the named arguments.
Tag	The type of the named argument.
Fallback	The fallback type to use if the named argument is not present.

This metafunction returns the type of a named argument in a list of named arguments. If the named argument is not present in the list of named arguments, the fallback type is returned instead, if Tag is a template argument.

See also

NamedArguments

NamedArgumentValue

template<typename Args, typename Tag>

using di::meta::NamedArgumentValue = meta::Decay<NamedArgument<Args, Tag>>

A metafunction to get the value type of a named argument.

Template Parameters

Args	The type of the named argument.
Tag	The type of the named argument.

This metafunction is equivalent to meta::NamedArgument, but it returns a value instead of a reference.

See also

NamedArguments

NamedArgumentValueOr

template<typename Args, typename Tag, typename Fallback>

using di::meta::NamedArgumentValueOr = meta::Decay<NamedArgumentOr<Args, Tag, Fallback>>

A metafunction to get the value type of a named argument with fallback.

Template Parameters

Args	The type of the named arguments.
Tag	The type of the named argument.
Fallback	The fallback value to use if the named argument is not present.

This metafunction is equivalent to meta::NamedArgumentOr, but it returns a value instead of a reference.

See also

NamedArguments

NextSenderOf

template<typename Rec, typename Send>

using di::meta::NextSenderOf = decltype(execution::set_next(util::declval<meta::RemoveCVRef<Rec>&>(), util::declval<Send>()))

OptionalValue

template<concepts::Optional T>

using di::meta::OptionalValue = meta::RemoveCVRef<T>::Value

ParserContextError

template<concepts::ParserContext Context>

using di::meta::ParserContextError = Context::Error

ParserContextResult

template<typename T, concepts::ParserContext Context>

using di::meta::ParserContextResult = vocab::Expected<T, meta::ParserContextError<Context>>

ParserValue

template<concepts::ParserContext Context, concepts::Parser< Context > Parser>

using di::meta::ParserValue = meta::ExpectedValue<decltype(util::declval<Parser&>().parse(util::declval<Context&>()))>

PeerMessageTypesWithoutReplies

template<concepts::HasProtocol T>

using di::meta::PeerMessageTypesWithoutReplies

Initial value:

 
    Conditional<is_client<T>, typename meta::Protocol<T>::Server,
                Conditional<is_server<T>, typename meta::Protocol<T>::Client, detail::MustBeClientOrServer>>

PopBack

template<concepts::TypeList L>

using di::meta::PopBack = Type<detail::PopBackHelper<L>>

PopFront

template<concepts::TypeList L>

using di::meta::PopFront = Type<detail::PopFrontHelper<L>>

Protocol

template<typename T>

using di::meta::Protocol = typename T::Protocol

PushBack

template<concepts::TypeList L, typename T>

using di::meta::PushBack = Concat<L, List<T>>

PushFront

template<concepts::TypeList L, typename T>

using di::meta::PushFront = Concat<List<T>, L>

ReaderResult

template<typename T, concepts::Impl< io::Reader > Reader>

using di::meta::ReaderResult

Initial value:

 
    meta::LikeExpected<decltype(io::read_some(util::declval<Reader&>(), util::declval<Span<Byte>>())), T>

Reconstructed

template<typename T, typename It = ContainerIterator<T>, typename Sent = ContainerSentinel<T>>

using di::meta::Reconstructed = decltype(container::reconstruct(in_place_type<T>, util::declval<It>(), util::declval<Sent>()))

Reflect

template<concepts::Reflectable T>

using di::meta::Reflect = decltype(reflection::reflect(in_place_type<T>))

RemoveAllExtents

template<typename T>

using di::meta::RemoveAllExtents = Type<detail::RemoveAllExtentsHelper<T>>

RemoveConst

template<typename T>

using di::meta::RemoveConst = Type<detail::RemoveConstHelper<T>>

RemoveCV

template<typename T>

using di::meta::RemoveCV = RemoveConst<RemoveVolatile<T>>

RemoveCVRef

template<typename T>

using di::meta::RemoveCVRef = RemoveCV<RemoveReference<T>>

RemoveExtent

template<typename T>

using di::meta::RemoveExtent = Type<detail::RemoveExtentHelper<T>>

RemoveFunctionQualifiers

template<typename T>

using di::meta::RemoveFunctionQualifiers = Type<detail::RemoveFunctionQualifiersHelper<T>>

RemovePointer

template<typename T>

using di::meta::RemovePointer = Type<detail::RemovePointerHelper<T>>

RemoveReference

template<typename T>

using di::meta::RemoveReference = Type<detail::RemoveReferenceHelper<T>>

RemoveRValueReference

template<typename T>

using di::meta::RemoveRValueReference = Conditional<concepts::RValueReference<T>, RemoveReference<T>, T>

RemoveVolatile

template<typename T>

using di::meta::RemoveVolatile = Type<detail::RemoveVolatile<T>>

Repeat

template<typename T, usize N>

using di::meta::Repeat = Type<detail::RepeatHelper<T, N>>

Replace

template<concepts::TypeList List, typename Needle, typename Replacement>

using di::meta::Replace = Fold<List, meta::List<>, detail::ReplaceReducer<Needle, Replacement>>

ReplaceIf

template<concepts::TypeList List, concepts::MetaInvocable Pred, typename Replacement>

using di::meta::ReplaceIf = Fold<List, meta::List<>, detail::ReplaceIfReducer<Pred, Replacement>>

ScheduleResult

template<typename Sched>

using di::meta::ScheduleResult = decltype(execution::schedule(util::declval<Sched>()))

SequenceCompletionSignaturesOf

template<typename Send, typename Env>

using di::meta::SequenceCompletionSignaturesOf

Initial value:

 
    meta::MakeCompletionSignatures<Send, Env, types::CompletionSignatures<execution::SetValue()>,
                                   meta::TypeConstant<types::CompletionSignatures<>>::template Invoke>

SerializationFormat

template<concepts::Serializer S>

using di::meta::SerializationFormat = typename meta::RemoveCVRef<S>::SerializationFormat

SerializeMetadata

template<concepts::SerializationFormat S, typename T>

using di::meta::SerializeMetadata = decltype(serialization::serialize_metadata(in_place_type<T>, in_place_type<S>))

Serializer

template<typename T, typename Writer = any::AnyRef<io::Writer>, typename... Args>

using di::meta::Serializer

Initial value:

 
    decltype(serialization::serializer(util::declval<T>(), util::declval<Writer>(), util::declval<Args>()...))

SerializeResult

template<typename S>

using di::meta::SerializeResult = meta::WriterResult<void, decltype(util::declval<S>().writer())>

SingleSenderValueType

template<typename Send, typename Env>

using di::meta::SingleSenderValueType

Initial value:

 
    ValueTypesOf<Send, Env, detail::SingleSenderValueTypeHelper, detail::SingleSenderValueTypeHelper>

StatusCodeDomain

template<typename T>

using di::meta::StatusCodeDomain = detail::StatusCodeDomainHelper<T>::Type

StatusCodeDomainValue

template<typename T>

using di::meta::StatusCodeDomainValue = detail::StatusCodeDomainValueHelper<T>::Type

StopTokenOf

template<typename T>

using di::meta::StopTokenOf = meta::RemoveCVRef<decltype(execution::get_stop_token(util::declval<T>()))>

SubscribeResult

template<typename Send, typename Rec>

using di::meta::SubscribeResult = decltype(execution::subscribe(util::declval<Send>(), util::declval<Rec>()))

TagInvokeResult

template<typename Tag, typename... Args>

using di::meta::TagInvokeResult = decltype(di::function::tag_invoke(util::declval<Tag>(), util::declval<Args>()...))

Transform

template<concepts::TypeList List, typename Function>

using di::meta::Transform = detail::TransformHelper<List, Function>::Type

TupleElement

template<typename T, types::size_t index>

using di::meta::TupleElement = decltype(vocab::tuple_element(types::in_place_type<meta::RemoveReference<T>>, c_<index>))::Type

TupleElements

template<concepts::TupleLike Tup>

using di::meta::TupleElements

Initial value:

 
    meta::Transform<meta::AsList<meta::MakeIndexSequence<meta::TupleSize<Tup>>>, detail::GetElement<Tup>>

TupleValue

template<concepts::TupleLike Tup, types::size_t index>

using di::meta::TupleValue = decltype(util::get<index>(util::declval<Tup>()))

Type

template<concepts::Trait T>

using di::meta::Type = T::Type

TypeIdentity

template<typename T>

using di::meta::TypeIdentity = Type<TypeConstant<T>>

This is a helper template to prevent C++ from deducing the type of template argument.

This will force users/callers to specify the template types inside the <> brackets.

UnderlyingType

template<concepts::Enum T>

using di::meta::UnderlyingType = __underlying_type(T)

Unique

template<concepts::TypeList Lst>

using di::meta::Unique = Fold<Lst, List<>, detail::PushBackIfUnique>

UnwrapExpected

template<typename T>

using di::meta::UnwrapExpected = Invoke<Conditional<concepts::Expected<T>, meta::Quote<ExpectedValue>, meta::TypeConstant<T>>, T>

UnwrapRefDecay

template<typename T>

using di::meta::UnwrapRefDecay = UnwrapReference<Decay<T>>

UnwrapReference

template<typename T>

using di::meta::UnwrapReference = detail::UnwrapReferenceHelper<T>::Type

UnwrapRefRValue

template<typename T>

using di::meta::UnwrapRefRValue = RemoveRValueReference<UnwrapReference<T>>

ValueTypesOf

template<typename Sender, typename Env = types::EmptyEnv, template< typename... > typename Tup = meta::DecayedTuple, template< typename... > typename Var = meta::VariantOrEmpty>

using di::meta::ValueTypesOf = GatherSignatures<execution::SetValue, Sender, Env, Tup, Var>

VariantAlternative

template<typename T, size_t index>

using di::meta::VariantAlternative = decltype(vocab::variant_alternative(in_place_type<meta::RemoveReference<T>>, c_<index>))

VariantOrEmpty

template<typename... Types>

using di::meta::VariantOrEmpty = detail::VariantOrEmptyHelper<meta::Unique<meta::List<Types...>>>::Type

VariantTypes

template<typename T>

using di::meta::VariantTypes = decltype(vocab::variant_types(in_place_type<meta::RemoveCVRef<T>>))

VariantValue

template<concepts::VariantLike Var, size_t index>

using di::meta::VariantValue = decltype(util::get<index>(util::declval<Var>()))

WrapReference

template<typename T>

using di::meta::WrapReference = detail::WrapReference<T>::Type

WriterResult

template<typename T, concepts::Impl< io::Writer > Writer>

using di::meta::WriterResult

Initial value:

 
    meta::LikeExpected<decltype(io::write_some(util::declval<Writer&>(), util::declval<Span<Byte const>>())), T>

Zip

template<concepts::TypeList T, concepts::TypeList U>

using di::meta::Zip = Type<detail::ZipHelper<T, U>>

Variable Documentation

All

template<concepts::TypeList List, concepts::MetaInvocable Pred>

bool di::meta::All = detail::AllHelper<Pred, List>::value

inlineconstexpr

ArrayRank

template<typename T>

auto di::meta::ArrayRank = 0ZU

inlineconstexpr

ArrayRank< T[]>

template<typename T>

auto di::meta::ArrayRank< T[]> = 1 + ArrayRank<T>

inlineconstexpr

ArrayRank< T[N]>

template<typename T, usize N>

auto di::meta::ArrayRank< T[N]> = 1 + ArrayRank<T>

inlineconstexpr

c_

template<auto val>

auto di::meta::c_ = Constexpr<val> {}

inlineconstexpr

A value of type Constexpr<val>.

Template Parameters

val	The value of the Constexpr.

See also

Constexpr

ExpectedRank

template<typename T>

auto di::meta::ExpectedRank = 0ZU

inlineconstexpr

ExpectedRank< T >

template<concepts::Expected T>

auto di::meta::ExpectedRank< T > = 1 + ExpectedRank<ExpectedValue<T>>

inlineconstexpr

Extent

template<typename T, types::size_t level = 0>

auto di::meta::Extent = 0ZU

inlineconstexpr

Extent< T[], level >

template<typename T, usize level>

auto di::meta::Extent< T[], level > = Extent<T, level - 1>

inlineconstexpr

Extent< T[size], 0 >

template<typename T, usize size>

auto di::meta::Extent< T[size], 0 > = size

inlineconstexpr

Extent< T[size], level >

template<typename T, usize size, usize level>

auto di::meta::Extent< T[size], level > = Extent<T, level - 1>

inlineconstexpr

matching_sig

template<typename A, typename B>

bool di::meta::matching_sig = false

inlineconstexpr

matching_sig< T(A...), U(B...)>

template<typename T, typename... A, typename U, typename... B>

bool di::meta::matching_sig< T(A...), U(B...)> = concepts::SameAs<T(A&&...), U(B&&...)>

inlineconstexpr

OptionalRank

template<typename T>

auto di::meta::OptionalRank = 0ZU

inlineconstexpr

OptionalRank< T >

template<concepts::Optional T>

auto di::meta::OptionalRank< T > = 1 + OptionalRank<OptionalValue<T>>

inlineconstexpr

sends_stopped

template<typename Sender, typename Env = types::EmptyEnv>

bool di::meta::sends_stopped

inlineconstexpr

Initial value:

=
    (!concepts::SameAs<List<>, GatherSignatures<execution::SetStopped, Sender, Env, List, List>>)

SequenceCardinality

template<typename Sequence>

auto di::meta::SequenceCardinality

inlineconstexpr

Initial value:

=
    !concepts::SequenceSender<Sequence>
        ? 1ZU
        : meta::InvokeResult<decltype(execution::get_sequence_cardinality), meta::EnvOf<Sequence>>::value

Gets the cardinality of a sequence.

Template Parameters

Sequence

The sequence to get the cardinality of.

See also

execution::get_sequence_cardinality

Size

template<concepts::TypeList T>

usize di::meta::Size = T::size

inlineconstexpr

TupleSize

template<typename T>

auto di::meta::TupleSize = vocab::tuple_size(types::in_place_type<meta::RemoveCVRef<T>>)

inlineconstexpr

VariantSize

template<typename T>

auto di::meta::VariantSize = vocab::variant_size(in_place_type<meta::RemoveCVRef<T>>)

inlineconstexpr