di::vocab Namespace Reference

Namespaces
namespace	byte_buffer
namespace	detail

Classes
struct	AdoptObject
struct	ArcTag
struct	Array
struct	Array< T, 0 >
class	BasicOptionalStorage
class	Box
struct	ConstructTupleImplFromTuplelike
struct	ConstructTupleImplValuewise
class	DefaultAccessor
struct	DefaultDelete
struct	EnableGenerateStructedBindingsFunction
struct	Erased
class	Expected
class	Expected< T, E >
class	Expected< T, void >
class	Expected< void, E >
class	Expected< void, void >
class	Extents
struct	GetValueFunction
class	IntrusivePtr
struct	IntrusiveRefCount
struct	IntrusiveThreadUnsafeRefCount
struct	IsNulloptFunction
struct	LayoutLeft
struct	LayoutRight
struct	LayoutStride
struct	MakeArcFunction
struct	MakeRcFunction
class	MDSpan
struct	NullOpt
class	Optional
class	Optional< T >
class	Optional< void >
struct	RcTag
struct	RetainObject
struct	SetNulloptFunction
struct	SetValueFunction
class	Span
class	Span< T, dynamic_extent >
class	Span< T, extent >
class	StatusCode
class	StatusCode< Erased< T > >
class	StatusCode< T >
class	StatusCode< void >
class	StatusCodeDomain
class	Tuple
struct	TupleElementFunction
class	TupleImpl
class	TupleImpl< meta::ListV< index, indices... >, T, Rest... >
class	TupleImpl< meta::ListV<> >
struct	TupleSizeFunction
class	Unexpected
class	Variant

Concepts
concept	ConstructibleFromCRefOptional
concept	OptionalStorage

Typedefs
using	Error = StatusCode<Erased<long>>
template<typename T = void>
using	Result = Expected<T, Error>
using	GenericCode = StatusCode<platform::GenericDomain>
template<typename SizeType, usize rank>
using	Dextents = detail::DextentsHelper<SizeType, meta::Repeat<Constexpr<dynamic_extent>, rank>>::Type
template<typename Storage>
using	OptionalGetValue = decltype(get_value(util::declval<Storage>()))
template<typename T>
using	StorageFor
template<typename T>
using	Arc = IntrusivePtr<T, ArcTag>
template<typename T>
using	Rc = IntrusivePtr<T, RcTag>

Functions
template<concepts::Expected T, typename Promise>
constexpr auto	tag_invoke (types::Tag< execution::as_awaitable >, T &&value, Promise &promise) -> decltype(auto)
template<typename T, typename... U>
	Array (T, U...) -> Array< T, 1+sizeof...(U)>
template<typename T, types::size_t size> requires (concepts::CopyConstructible<T> && !concepts::LanguageArray<T>)
constexpr auto	to_array (T(&array)[size])
template<typename T, types::size_t size> requires (concepts::MoveConstructible<T> && !concepts::LanguageArray<T>)
constexpr auto	to_array (T(&&array)[size]) -> Array< meta::RemoveCV< T >, size >
template<typename T, typename U>
constexpr auto	operator== (StatusCode< T > const &a, StatusCode< U > const &b) -> bool
template<typename T, typename U> requires (concepts::ConvertibleToAnyStatusCode<U const&>)
constexpr auto	operator== (StatusCode< T > const &a, U const &b) -> bool
template<typename T, typename U> requires (concepts::ConvertibleToAnyStatusCode<T const&>)
constexpr auto	operator== (T const &a, U const &b) -> bool
template<typename T>
	Expected (T &&) -> Expected< meta::UnwrapRefDecay< T >, void >
template<typename E>
	Unexpected (E &&) -> Unexpected< meta::UnwrapRefDecay< E > >
template<typename... Integrals> requires (concepts::ConvertibleTo<Integrals, size_t> && ...)
	Extents (Integrals...) -> Extents< size_t,(Integrals {}, dynamic_extent)... >
template<concepts::LanguageArray CArray> requires (meta::ArrayRank<CArray> == 1)
	MDSpan (CArray &) -> MDSpan< meta::RemoveAllExtents< CArray >, Extents< size_t, meta::Extent< CArray, 0 > > >
template<typename Pointer> requires (concepts::Pointer<meta::RemoveReference<Pointer>>)
	MDSpan (Pointer &&) -> MDSpan< meta::RemovePointer< meta::RemoveReference< Pointer > >, Extents< size_t > >
template<typename ElementType, typename... integrals> requires (sizeof...(integrals) > 0 && (concepts::ConvertibleTo<integrals, size_t> && ...))
	MDSpan (ElementType *, integrals...) -> MDSpan< ElementType, Dextents< size_t, sizeof...(integrals)> >
template<typename ElementType, typename OtherSizeType, size_t N>
	MDSpan (ElementType *, Span< OtherSizeType, N >) -> MDSpan< ElementType, Dextents< size_t, N > >
template<typename ElementType, typename OtherSizeType, size_t N>
	MDSpan (ElementType *, Array< OtherSizeType, N > const &) -> MDSpan< ElementType, Dextents< size_t, N > >
template<typename ElementType, typename SizeType, size_t... extents>
	MDSpan (ElementType *, Extents< SizeType, extents... > const &) -> MDSpan< ElementType, Extents< SizeType, extents... > >
template<class ElementType, class MappingType>
	MDSpan (ElementType *, MappingType const &) -> MDSpan< ElementType, typename MappingType::ExtentsType, typename MappingType::LayoutType >
template<class MappingType, class AccessorType>
	MDSpan (typename AccessorType::DataHandle const &, MappingType const &, AccessorType const &) -> MDSpan< typename AccessorType::ElementType, typename MappingType::ExtentsType, typename MappingType::LayoutType, AccessorType >
template<typename T>
constexpr auto	make_optional (T &&value)
template<typename T, typename... Args>
constexpr auto	make_optional (Args &&... args)
template<typename T, concepts::EqualityComparableWith< T > U>
constexpr auto	operator== (Optional< T > const &a, Optional< U > const &b) -> bool
template<typename T>
constexpr auto	operator== (Optional< T > const &a, NullOpt) -> bool
template<typename T, typename U> requires ((meta::OptionalRank<T> >= meta::OptionalRank<U>) && concepts::EqualityComparableWith<T, U>)
constexpr auto	operator== (Optional< T > const &a, U const &b) -> bool
template<typename T, concepts::ThreeWayComparableWith< T > U>
constexpr auto	operator<=> (Optional< T > const &a, Optional< U > const &b) -> meta::CompareThreeWayResult< T, U >
template<typename T>
constexpr auto	operator<=> (Optional< T > const &a, NullOpt) -> types::strong_ordering
template<typename T, typename U> requires ((meta::OptionalRank<T> >= meta::OptionalRank<U>) && concepts::ThreeWayComparableWith<T, U>)
constexpr auto	operator<=> (Optional< T > const &a, U const &b) -> meta::CompareThreeWayResult< T, U >
template<class T>
	Optional (T) -> Optional< T >
template<size_t count, typename T>
constexpr auto	fixed_span (T *value) -> Span< T, count >
template<typename Iter, typename SentOrSize>
	Span (Iter, SentOrSize) -> Span< meta::RemoveReference< meta::IteratorReference< Iter > > >
template<typename Con>
	Span (Con &&) -> Span< meta::RemoveReference< meta::ContainerReference< Con > > >
template<typename T, types::size_t size>
	Span (T(&)[size]) -> Span< T, size >
template<typename T, types::size_t size>
	Span (vocab::Array< T, size > &) -> Span< T, size >
template<typename T, types::size_t size>
	Span (vocab::Array< T, size > const &) -> Span< T const, size >
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... Types>
	Tuple (Types...) -> Tuple< Types... >
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 T, concepts::VariantLike Var, typename List = meta::VariantTypes<Var>, auto index = meta::Lookup<T, List>, typename Res = meta::VariantValue<Var, index>> requires (meta::UniqueType<T, List>)
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
template<typename Vis, concepts::VariantLike... Vars, typename R = decltype(function::invoke(util::declval<Vis>(), util::get<0>(util::declval<Vars>())...))>
constexpr auto	visit (Vis &&visitor, Vars &&... variants) -> decltype(auto) requires(

Variables
constexpr auto	into_status_code = detail::IntoStatusCodeFunction {}
constexpr auto	as_fallible = detail::AsFallibleFunction {}
constexpr auto	if_error = function::curry_back(detail::IfErrorFunction {}, meta::c_<2ZU>)
constexpr auto	if_success = function::curry_back(detail::IfSuccessFunction {}, meta::c_<2ZU>)
constexpr auto	invoke_as_fallible = detail::InvokeAsFallibleFunction {}
constexpr auto	try_infallible = detail::TryInfallibleFunction {}
constexpr auto	get_value = GetValueFunction {}
constexpr struct di::vocab::IsNulloptFunction	is_nullopt
constexpr auto	lift_bool = detail::LiftBoolFunction {}
constexpr auto	nullopt = NullOpt { 0 }
constexpr struct di::vocab::SetNulloptFunction	set_nullopt
constexpr struct di::vocab::SetValueFunction	set_value
template<detail::IntrusivePtrValid< ArcTag > T>
constexpr auto	make_arc = MakeArcFunction<T> {}
template<typename T>
constexpr auto	make_box = detail::MakeBoxFunction<T> {}
constexpr auto	retain_object = RetainObject {}
constexpr auto	adopt_object = AdoptObject {}
constexpr auto	intrusive_ptr_increment = detail::IntrusivePtrIncrement {}
constexpr auto	intrusive_ptr_decrement = detail::IntrusivePtrDecrement {}
template<detail::IntrusivePtrValid< RcTag > T>
constexpr auto	make_rc = MakeRcFunction<T> {}
constexpr auto	as_bytes = detail::AsBytesFunction {}
constexpr auto	as_writable_bytes = detail::AsWritableBytesFunction {}
constexpr auto	dynamic_extent = math::NumericLimits<types::size_t>::max
constexpr struct di::vocab::EnableGenerateStructedBindingsFunction	enable_generate_structed_bindings
template<typename T>
constexpr auto	make_from_tuple = detail::MakeFromTupleFunction<T> {}
constexpr auto	tie = detail::TieFunction {}
constexpr auto	tuple_element = TupleElementFunction {}
constexpr auto	construct_tuple_impl_valuewise = ConstructTupleImplValuewise {}
constexpr auto	construct_tuple_impl_from_tuplelike = ConstructTupleImplFromTuplelike {}
template<typename R>
constexpr auto	tuple_sequence = detail::TupleSequenceFunction<R> {}
constexpr auto	tuple_size = TupleSizeFunction {}
template<typename T>
constexpr auto	holds_alternative = detail::HoldsAlternativeFunction<T> {}
constexpr auto	variant_alternative = detail::VariantAlternativeFunction {}
constexpr auto	variant_index = detail::VariantIndexFunction {}
constexpr auto	variant_size = detail::VariantSizeFunction {}
constexpr auto	variant_types = detail::VariantTypesFunction {}

Typedef Documentation

Arc

template<typename T>

using di::vocab::Arc = IntrusivePtr<T, ArcTag>

Dextents

template<typename SizeType, usize rank>

using di::vocab::Dextents = detail::DextentsHelper<SizeType, meta::Repeat<Constexpr<dynamic_extent>, rank>>::Type

Error

using di::vocab::Error = StatusCode<Erased<long>>

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

GenericCode

using di::vocab::GenericCode = StatusCode<platform::GenericDomain>

OptionalGetValue

template<typename Storage>

using di::vocab::OptionalGetValue = decltype(get_value(util::declval<Storage>()))

Rc

template<typename T>

using di::vocab::Rc = IntrusivePtr<T, RcTag>

Result

template<typename T = void>

using di::vocab::Result = Expected<T, Error>

StorageFor

template<typename T>

using di::vocab::StorageFor

Initial value:

 
    meta::Conditional<OptionalStorage<meta::WrapReference<T>, T>, meta::WrapReference<T>, BasicOptionalStorage<T>>

Function Documentation

apply()

template<typename F, concepts::TupleLike Tup>

auto di::vocab::apply ( F && f, Tup && tuple ) -> decltype(detail::apply_impl(meta::MakeIndexSequence<meta::TupleSize<Tup>> {}, util::forward<F>(f), util::forward<Tup>(tuple)))

constexpr

Array()

template<typename T, typename... U>

di::vocab::Array	(	T	,
		U...	) -> Array< T, 1+sizeof...(U)>

Expected()

template<typename T>

di::vocab::Expected

(

T &&

)

-> Expected< meta::UnwrapRefDecay< T >, void >

Extents()

template<typename... Integrals>
requires (concepts::ConvertibleTo<Integrals, size_t> && ...)

di::vocab::Extents ( Integrals... ) -> Extents< size_t,(Integrals {}, dynamic_extent)... >

explicit

fixed_span()

template<size_t count, typename T>

auto di::vocab::fixed_span ( T * value ) -> Span<T, count>

constexpr

forward_as_tuple()

template<typename... Args>

auto di::vocab::forward_as_tuple ( Args &&... args ) -> Tuple<Args&&...>

constexpr

get_if() [1/2]

template<size_t index, concepts::VariantLike Var, typename Res = meta::VariantValue<Var, index>>

auto di::vocab::get_if ( Var && variant ) -> Optional<meta::RemoveRValueReference<Res>>

constexpr

get_if() [2/2]

template<typename T, concepts::VariantLike Var, typename List = meta::VariantTypes<Var>, auto index = meta::Lookup<T, List>, typename Res = meta::VariantValue<Var, index>>
requires (meta::UniqueType<T, List>)

auto di::vocab::get_if ( Var && variant ) -> Optional<meta::RemoveRValueReference<Res>>

constexpr

make_decayed_tuple()

template<typename... Args>

auto di::vocab::make_decayed_tuple ( Args &&... args )

constexpr

make_optional() [1/2]

template<typename T, typename... Args>

auto di::vocab::make_optional ( Args &&... args )

constexpr

make_optional() [2/2]

template<typename T>

auto di::vocab::make_optional ( T && value )

constexpr

make_tuple()

template<typename... Args>

auto di::vocab::make_tuple ( Args &&... args )

constexpr

MDSpan() [1/8]

template<concepts::LanguageArray CArray>
requires (meta::ArrayRank<CArray> == 1)

di::vocab::MDSpan

(

CArray &

)

-> MDSpan< meta::RemoveAllExtents< CArray >, Extents< size_t, meta::Extent< CArray, 0 > > >

MDSpan() [2/8]

template<typename ElementType, typename OtherSizeType, size_t N>

di::vocab::MDSpan	(	ElementType *	,
		Array< OtherSizeType, N > const &	) -> MDSpan< ElementType, Dextents< size_t, N > >

MDSpan() [3/8]

template<typename ElementType, typename SizeType, size_t... extents>

di::vocab::MDSpan	(	ElementType *	,
		Extents< SizeType, extents... > const &	) -> MDSpan< ElementType, Extents< SizeType, extents... > >

MDSpan() [4/8]

template<typename ElementType, typename... integrals>
requires (sizeof...(integrals) > 0 && (concepts::ConvertibleTo<integrals, size_t> && ...))

di::vocab::MDSpan ( ElementType * , integrals...  ) -> MDSpan< ElementType, Dextents< size_t, sizeof...(integrals)> >

explicit

MDSpan() [5/8]

template<class ElementType, class MappingType>

di::vocab::MDSpan	(	ElementType *	,
		MappingType const &	) -> MDSpan< ElementType, typename MappingType::ExtentsType, typename MappingType::LayoutType >

MDSpan() [6/8]

template<typename ElementType, typename OtherSizeType, size_t N>

di::vocab::MDSpan	(	ElementType *	,
		Span< OtherSizeType, N >	) -> MDSpan< ElementType, Dextents< size_t, N > >

MDSpan() [7/8]

template<typename Pointer>
requires (concepts::Pointer<meta::RemoveReference<Pointer>>)

di::vocab::MDSpan

(

Pointer &&

)

-> MDSpan< meta::RemovePointer< meta::RemoveReference< Pointer > >, Extents< size_t > >

MDSpan() [8/8]

template<class MappingType, class AccessorType>

di::vocab::MDSpan	(	typename AccessorType::DataHandle const &	,
		MappingType const &	,
		AccessorType const &	) -> MDSpan< typename AccessorType::ElementType, typename MappingType::ExtentsType, typename MappingType::LayoutType, AccessorType >

operator<=>() [1/3]

template<typename T>

auto di::vocab::operator<=> ( Optional< T > const & a, NullOpt  ) -> types::strong_ordering

constexpr

operator<=>() [2/3]

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

auto di::vocab::operator<=> ( Optional< T > const & a, Optional< U > const & b ) -> meta::CompareThreeWayResult<T, U>

constexpr

operator<=>() [3/3]

template<typename T, typename U>
requires ((meta::OptionalRank<T> >= meta::OptionalRank<U>) && concepts::ThreeWayComparableWith<T, U>)

auto di::vocab::operator<=> ( Optional< T > const & a, U const & b ) -> meta::CompareThreeWayResult<T, U>

constexpr

operator==() [1/6]

template<typename T>

auto di::vocab::operator== ( Optional< T > const & a, NullOpt  ) -> bool

constexpr

operator==() [2/6]

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

auto di::vocab::operator== ( Optional< T > const & a, Optional< U > const & b ) -> bool

constexpr

operator==() [3/6]

template<typename T, typename U>
requires ((meta::OptionalRank<T> >= meta::OptionalRank<U>) && concepts::EqualityComparableWith<T, U>)

auto di::vocab::operator== ( Optional< T > const & a, U const & b ) -> bool

constexpr

operator==() [4/6]

template<typename T, typename U>

auto di::vocab::operator== ( StatusCode< T > const & a, StatusCode< U > const & b ) -> bool

constexpr

operator==() [5/6]

template<typename T, typename U>
requires (concepts::ConvertibleToAnyStatusCode<U const&>)

auto di::vocab::operator== ( StatusCode< T > const & a, U const & b ) -> bool

constexpr

operator==() [6/6]

template<typename T, typename U>
requires (concepts::ConvertibleToAnyStatusCode<T const&>)

auto di::vocab::operator== ( T const & a, U const & b ) -> bool

constexpr

Optional()

template<class T>

di::vocab::Optional

(

T

)

-> Optional< T >

Span() [1/5]

template<typename Con>

di::vocab::Span

(

Con &&

)

-> Span< meta::RemoveReference< meta::ContainerReference< Con > > >

Span() [2/5]

template<typename Iter, typename SentOrSize>

di::vocab::Span	(	Iter	,
		SentOrSize	) -> Span< meta::RemoveReference< meta::IteratorReference< Iter > > >

Span() [3/5]

template<typename T, types::size_t size>

di::vocab::Span

(

T(&)

[size]

)

-> Span< T, size >

Span() [4/5]

template<typename T, types::size_t size>

di::vocab::Span

(

vocab::Array< T, size > &

)

-> Span< T, size >

Span() [5/5]

template<typename T, types::size_t size>

di::vocab::Span

(

vocab::Array< T, size > const &

)

-> Span< T const, size >

tag_invoke()

template<concepts::Expected T, typename Promise>

auto di::vocab::tag_invoke ( types::Tag< execution::as_awaitable > , T && value, Promise & promise ) -> decltype(auto)

constexpr

to_array() [1/2]

template<typename T, types::size_t size>
requires (concepts::MoveConstructible<T> && !concepts::LanguageArray<T>)

auto di::vocab::to_array ( T(&&) array[size] ) -> Array<meta::RemoveCV<T>, size>

constexpr

to_array() [2/2]

template<typename T, types::size_t size>
requires (concepts::CopyConstructible<T> && !concepts::LanguageArray<T>)

auto di::vocab::to_array ( T(&) array[size] )

constexpr

Tuple()

template<typename... Types>

di::vocab::Tuple

(

Types...

)

-> Tuple< Types... >

tuple_cat()

template<concepts::TupleLike... Tups>

auto di::vocab::tuple_cat ( Tups &&... tuples )

constexpr

tuple_for_each()

template<typename F, concepts::TupleLike Tup>
requires (detail::TupleForEachValid<F, Tup, meta::MakeIndexSequence<meta::TupleSize<Tup>>>::value)

void di::vocab::tuple_for_each ( F && function, Tup && tuple )

constexpr

tuple_transform()

template<typename F, concepts::TupleLike Tup>
requires (detail::TupleTransformValid<F, Tup, meta::MakeIndexSequence<meta::TupleSize<Tup>>>::value)

auto di::vocab::tuple_transform ( F && function, Tup && tuple )

constexpr

Unexpected()

template<typename E>

di::vocab::Unexpected

(

E &&

)

-> Unexpected< meta::UnwrapRefDecay< E > >

visit() [1/2]

template<typename Vis, concepts::VariantLike... Vars, typename R = decltype(function::invoke(util::declval<Vis>(), util::get<0>(util::declval<Vars>())...))>

auto di::vocab::visit ( Vis && visitor, Vars &&... variants ) -> decltype(auto) requires(

constexpr

visit() [2/2]

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 {}); })

auto di::vocab::visit ( Vis && visitor, Vars &&... variants ) -> R

constexpr

Variable Documentation

adopt_object

auto di::vocab::adopt_object = AdoptObject {}

inlineconstexpr

as_bytes

auto di::vocab::as_bytes = detail::AsBytesFunction {}

inlineconstexpr

as_fallible

auto di::vocab::as_fallible = detail::AsFallibleFunction {}

inlineconstexpr

as_writable_bytes

auto di::vocab::as_writable_bytes = detail::AsWritableBytesFunction {}

inlineconstexpr

construct_tuple_impl_from_tuplelike

auto di::vocab::construct_tuple_impl_from_tuplelike = ConstructTupleImplFromTuplelike {}

inlineconstexpr

construct_tuple_impl_valuewise

auto di::vocab::construct_tuple_impl_valuewise = ConstructTupleImplValuewise {}

inlineconstexpr

dynamic_extent

auto di::vocab::dynamic_extent = math::NumericLimits<types::size_t>::max

inlineconstexpr

enable_generate_structed_bindings

struct di::vocab::EnableGenerateStructedBindingsFunction di::vocab::enable_generate_structed_bindings

get_value

auto di::vocab::get_value = GetValueFunction {}

inlineconstexpr

holds_alternative

template<typename T>

auto di::vocab::holds_alternative = detail::HoldsAlternativeFunction<T> {}

inlineconstexpr

if_error

auto di::vocab::if_error = function::curry_back(detail::IfErrorFunction {}, meta::c_<2ZU>)

inlineconstexpr

if_success

auto di::vocab::if_success = function::curry_back(detail::IfSuccessFunction {}, meta::c_<2ZU>)

inlineconstexpr

into_status_code

auto di::vocab::into_status_code = detail::IntoStatusCodeFunction {}

inlineconstexpr

intrusive_ptr_decrement

auto di::vocab::intrusive_ptr_decrement = detail::IntrusivePtrDecrement {}

inlineconstexpr

intrusive_ptr_increment

auto di::vocab::intrusive_ptr_increment = detail::IntrusivePtrIncrement {}

inlineconstexpr

invoke_as_fallible

auto di::vocab::invoke_as_fallible = detail::InvokeAsFallibleFunction {}

inlineconstexpr

is_nullopt

struct di::vocab::IsNulloptFunction di::vocab::is_nullopt

lift_bool

auto di::vocab::lift_bool = detail::LiftBoolFunction {}

inlineconstexpr

make_arc

template<detail::IntrusivePtrValid< ArcTag > T>

auto di::vocab::make_arc = MakeArcFunction<T> {}

inlineconstexpr

make_box

template<typename T>

auto di::vocab::make_box = detail::MakeBoxFunction<T> {}

inlineconstexpr

make_from_tuple

template<typename T>

auto di::vocab::make_from_tuple = detail::MakeFromTupleFunction<T> {}

inlineconstexpr

make_rc

template<detail::IntrusivePtrValid< RcTag > T>

auto di::vocab::make_rc = MakeRcFunction<T> {}

inlineconstexpr

nullopt

auto di::vocab::nullopt = NullOpt { 0 }

inlineconstexpr

retain_object

auto di::vocab::retain_object = RetainObject {}

inlineconstexpr

set_nullopt

struct di::vocab::SetNulloptFunction di::vocab::set_nullopt

set_value

struct di::vocab::SetValueFunction di::vocab::set_value

tie

auto di::vocab::tie = detail::TieFunction {}

inlineconstexpr

try_infallible

auto di::vocab::try_infallible = detail::TryInfallibleFunction {}

inlineconstexpr

tuple_element

auto di::vocab::tuple_element = TupleElementFunction {}

inlineconstexpr

tuple_sequence

template<typename R>

auto di::vocab::tuple_sequence = detail::TupleSequenceFunction<R> {}

inlineconstexpr

tuple_size

auto di::vocab::tuple_size = TupleSizeFunction {}

inlineconstexpr

variant_alternative

auto di::vocab::variant_alternative = detail::VariantAlternativeFunction {}

inlineconstexpr

variant_index

auto di::vocab::variant_index = detail::VariantIndexFunction {}

inlineconstexpr

variant_size

auto di::vocab::variant_size = detail::VariantSizeFunction {}

inlineconstexpr

variant_types

auto di::vocab::variant_types = detail::VariantTypesFunction {}

inlineconstexpr