Namespace List

Here is a list of all namespaces with brief descriptions:

[detail level 123]

▼Nsl
►Nconcepts
Rright_shiftable_with	Determines whether two types can be used in operator >> statements
Rright_shiftable_with_r	Determines whether two types can be used in operator >> statements and checks if the return type is convertible to the expected
Rright_shiftable	Determines whether the given type can be used on both sides of operator >> statements
Rright_shiftable_r	Determines whether the given type can be used on both sides of operator >> statements and checks if the return type is convertible to the expected
Rleft_shiftable_with	Determines whether two types can be used in operator << statements
Rleft_shiftable_with_r	Determines whether two types can be used in operator << statements and checks if the return type is convertible to the expected
Rleft_shiftable	Determines whether the given type can be used on both sides of operator << statements
Rleft_shiftable_r	Determines whether the given type can be used on both sides of operator << statements and checks if the return type is convertible to the expected
Rbidirectional_shiftable_with	Determines whether two types can be used in operator >> and operator << statements
Rbidirectional_shiftable_with_r	Determines whether two types can be used in operator >> and operator << statements and checks if the return type is convertible to the expected
Rbidirectional_shiftable	Determines whether the given type can be used on both sides of operator << and operator >> statements
Rbidirectional_shiftable_r	Determines whether the given type can be used on both sides of operator >> and operator << statements and checks if the return type is convertible to the expected
Rright_shift_assignable_with	Determines whether two types can be used in operator >>= statements
Rright_shift_assignable_with_r	Determines whether two types can be used in operator >>= statements and checks if the return type is convertible to the expected
Rright_shift_assignable	Determines whether the given type can be used on both sides of operator >>= statements
Rright_shift_assignable_r	Determines whether the given type can be used on both sides of operator >>= statements and checks if the return type is convertible to the expected
Rleft_shift_assignable_with	Determines whether two types can be used in operator <<= statements
Rleft_shift_assignable_with_r	Determines whether two types can be used in operator <<= statements and checks if the return type is convertible to the expected
Rleft_shift_assignable	Determines whether the given type can be used on both sides of operator <<= statements
Rleft_shift_assignable_r	Determines whether the given type can be used on both sides of operator <<= statements and checks if the return type is convertible to the expected
Rbidirectional_shift_assignable_with	Determines whether two types can be used in operator >>= and operator <<= statements
Rbidirectional_shift_assignable_with_r	Determines whether two types can be used in operator >>= and operator <<= statements and checks if the return type is convertible to the expected
Rbidirectional_shift_assignable	Determines whether the given type can be used on both sides of operator <<= and operator >>= statements
Rbidirectional_shift_assignable_r	Determines whether the given type can be used on both sides of operator <<= and operator >>= statements and checks if the return type is convertible to the expected
Rfully_shiftable_with	Determines whether two types can be used in operator <<, >>, <<= and >>= statements
Rfully_shiftable_with_r	Determines whether two types can be used in operator <<, >>, <<= and >>= statements and checks if the return types are convertible to the expected ones
Rfully_shiftable	Determines whether the given type can be used on both sides of operator <<, >>, <<= and >>= statements
Rfully_shiftable_r	Determines whether the given type can be used on both sides of operator <<, >>, <<= and >>= statements and checks if the return types are convertible to the expected ones
Rcomplemented	Determines whether a type can be used in operator ~ expression
Rcomplemented_r	Determines whether a type can be used in operator ~ expression and if the return type is convertible to the expected one
Rconjunctive_with	Determines whether two types can be used in operator & expressions
Rconjunctive_with_r	Determines whether two types can be used in operator & expressions and if the return type is convertible to the expected one
Rconjunctive	Determines whether a type can be used on both sides of operator & expressions
Rconjunctive_r	Determines whether a type can be used on both sides of operator & expressions and if the return type is convertible to the expected one
Rconjunctive_assign_with	Determines whether two types can be used in operator &= expressions
Rconjunctive_assign_with_r	Determines whether two types can be used in operator &= expressions and if the return type is convertible to the expected one
Rconjunctive_assign	Determines whether a type can be used on both sides of operator &= expressions
Rconjunctive_assign_r	Determines whether a type can be used on both sides of operator &= expressions and if the return type is convertible to the expected one
Rdisjunctive_with	Determines whether two types can be used in operator | expressions
Rdisjunctive_with_r	Determines whether two types can be used in operator | expressions and if the return type is convertible to the expected one
Rdisjunctive	Determines whether a type can be used on both sides of operator | expressions
Rdisjunctive_r	Determines whether a type can be used on both sides of operator | expressions and if the return type is convertible to the expected one
Rdisjunctive_assign_with	Determines whether two types can be used in operator |= expressions
Rdisjunctive_assign_with_r	Determines whether two types can be used in operator |= expressions and if the return type is convertible to the expected one
Rdisjunctive_assign	Determines whether a type can be used on both sides of operator |= expressions
Rdisjunctive_assign_r	Determines whether a type can be used on both sides of operator |= expressions and if the return type is convertible to the expected one
Rexclusive_disjunctive_with	Determines whether two types can be used in operator ^ expressions
Rexclusive_disjunctive_with_r	Determines whether two types can be used in operator ^ expressions and if the return type is convertible to the expected one
Rexclusive_disjunctive	Determines whether a type can be used on both sides of operator ^ expressions
Rexclusive_disjunctive_r	Determines whether a type can be used on both sides of operator ^ expressions and if the return type is convertible to the expected one
Rexclusive_disjunctive_assign_with	Determines whether two types can be used in operator ^= expressions
Rexclusive_disjunctive_assign_with_r	Determines whether two types can be used in operator ^= expressions and if the return type is convertible to the expected one
Rexclusive_disjunctive_assign	Determines whether a type can be used on both sides of operator ^= expressions
Rexclusive_disjunctive_assign_r	Determines whether a type can be used on both sides of operator ^= expressions and if the return type is convertible to the expected one
Rlogically_combinable_with	Determines whether two types can be used in operator &, | amd ^ expressions
Rlogically_combinable_with_r	Determines whether two types can be used in operator &, | amd ^ expressions and if the return type is convertible to the expected one
Rlogically_combinable	Determines whether a type can be used on both sides of operator &, | and ^ expressions
Rlogically_combinable_r	Determines whether a type can be used on both sides of operator &, | and ^ expressions and if the return type is convertible to the expected one
Rlogically_assignable_with	Determines whether two types can be used in operator &=, |= and ^= expressions
Rlogically_assignable_with_r	Determines whether two types can be used in operator &=, |= and ^= expressions and if the return type is convertible to the expected one
Rlogically_assignable	Determines whether a type can be used on both sides of operator &=, |= and ^= expressions
Rlogically_assignable_r	Determines whether a type can be used on both sides of operator &=, |= and ^= expressions and if the return type is convertible to the expected one
Rfully_logical_with	Determines whether two types can be used in operator &, |, ^, &=, |=, ^= and ~ expressions
Rfully_logical_with_r	Determines whether two types can be used in operator &, |, ^, &=, |=, ^= and ~ expressions and if the return types are convertible to the expected ones
Rfully_logical	Determines whether a type can be used on both sides of operator &, |, ^, &=, |=, ^= and ~ expressions
Rfully_logical_r	Determines whether a type can be used on both sides of operator &, |, ^, &=, |=, ^= and ~ expressions and if the return types are convertible to the expected ones
Rinvertible
Rinvertible_r
Rdereferencable	Determines whether a type can be used in unary operator * expressions
Rdereferencable_r	Determines whether a type can be used in unary operator * expressions and if the return type is convertible to the expected one
Rarrow_dereferencable	Determines whether a type can be used in operator -> expressions
Rarrow_dereferencable_r	Determines whether a type can be used in operator -> expressions and if the return type is convertible to the expected one
Rindex_dereferencable	Determines whether a type can be used in operator [] expressions
Rindex_dereferencable_r	Determines whether a type can be used in operator -> expressions and if the return type is convertible to the expected one
Rnegate	Determines whether a type can be used in operator - expression
Rnegate_r	Determines whether a type can be used in operator - expression and if the return type is convertible to the expected one
Rplus_with	Determines whether two types can be used in operator + expressions
Rplus_with_r	Determines whether two types can be used in operator + expressions and if the return type is convertible to the expected one
Rplus	Determines whether a type can be used on both sides of operator + expressions
Rplus_r	Determines whether a type can be used on both sides of operator + expressions and if the return type is convertible to the expected one
Rplus_assign_with	Determines whether two types can be used in operator += expressions
Rplus_assign_with_r	Determines whether two types can be used in operator += expressions and if the return type is convertible to the expected one
Rplus_assign	Determines whether a type can be used on both sides of operator += expressions
Rplus_assign_r	Determines whether a type can be used on both sides of operator += expressions and if the return type is convertible to the expected one
Rminus_with	Determines whether two types can be used in operator - expressions
Rminus_with_r	Determines whether two types can be used in operator - expressions and if the return type is convertible to the expected one
Rminus	Determines whether a type can be used on both sides of operator - expressions
Rminus_r	Determines whether a type can be used on both sides of operator - expressions and if the return type is convertible to the expected one
Rminus_assign_with	Determines whether two types can be used in operator -= expressions
Rminus_assign_with_r	Determines whether two types can be used in operator -= expressions and if the return type is convertible to the expected one
Rminus_assign	Determines whether a type can be used on both sides of operator -= expressions
Rminus_assign_r	Determines whether a type can be used on both sides of operator -= expressions and if the return type is convertible to the expected one
Rmultiplies_with	Determines whether two types can be used in operator * expressions
Rmultiplies_with_r	Determines whether two types can be used in operator * expressions and if the return type is convertible to the expected one
Rmultiplies	Determines whether a type can be used on both sides of operator * expressions
Rmultiplies_r	Determines whether a type can be used on both sides of operator * expressions and if the return type is convertible to the expected one
Rmultiplies_assign_with	Determines whether two types can be used in operator *= expressions
Rmultiplies_assign_with_r	Determines whether two types can be used in operator *= expressions and if the return type is convertible to the expected one
Rmultiplies_assign	Determines whether a type can be used on both sides of operator *= expressions
Rmultiplies_assign_r	Determines whether a type can be used on both sides of operator *= expressions and if the return type is convertible to the expected one
Rdivides_with	Determines whether two types can be used in operator / expressions
Rdivides_with_r	Determines whether two types can be used in operator / expressions and if the return type is convertible to the expected one
Rdivides	Determines whether a type can be used on both sides of operator / expressions
Rdivides_r	Determines whether a type can be used on both sides of operator / expressions and if the return type is convertible to the expected one
Rdivides_assign_with	Determines whether two types can be used in operator /= expressions
Rdivides_assign_with_r	Determines whether two types can be used in operator /= expressions and if the return type is convertible to the expected one
Rdivides_assign	Determines whether a type can be used on both sides of operator /= expressions
Rdivides_assign_r	Determines whether a type can be used on both sides of operator /= expressions and if the return type is convertible to the expected one
Rmodulus_with	Determines whether two types can be used in operator % expressions
Rmodulus_with_r	Determines whether two types can be used in operator % expressions and if the return type is convertible to the expected one
Rmodulus	Determines whether a type can be used on both sides of operator % expressions
Rmodulus_r	Determines whether a type can be used on both sides of operator % expressions and if the return type is convertible to the expected one
Rmodulus_assign_with	Determines whether two types can be used in operator %= expressions
Rmodulus_assign_with_r	Determines whether two types can be used in operator %= expressions and if the return type is convertible to the expected one
Rmodulus_assign	Determines whether a type can be used on both sides of operator %= expressions
Rmodulus_assign_r	Determines whether a type can be used on both sides of operator %= expressions and if the return type is convertible to the expected one
Rarithmetically_combinable_with	Determines whether two types can be used in operator +, -, * and / expressions
Rarithmetically_combinable_with_r	Determines whether two types can be used in operator +, -, * and / expressions and if the return type is convertible to the expected one
Rarithmetically_combinable	Determines whether a type can be used on both sides of operator +, -, * and / expressions
Rarithmetically_combinable_r	Determines whether a type can be used on both sides of operator +, -, * and / expressions and if the return type is convertible to the expected one
Rarithmetically_assignable_with	Determines whether two types can be used in operator +=, -=, *= and /= expressions
Rarithmetically_assignable_with_r	Determines whether two types can be used in operator +=, -=, *= and /= expressions and if the return type is convertible to the expected one
Rarithmetically_assignable	Determines whether a type can be used on both sides of operator +=, -=, *= and /= expressions
Rarithmetically_assignable_r	Determines whether a type can be used on both sides of operator +=, -=, *= and /= expressions and if the return type is convertible to the expected one
Rfully_arithmetical_with	Determines whether two types can be used in operator +, -, *, /, +=, -=, *=, /= and unary - expressions
Rfully_arithmetical_with_r	Determines whether two types can be used in operator +, -, *, /, +=, -=, *=, /= and unary - expressions and if the return types are convertible to the expected ones
Rfully_arithmetical	Determines whether a type can be used on both sides of operator +, -, *, /, +=, -=, *=, /= and unary - expressions
Rfully_arithmetical_r	Determines whether a type can be used on both sides of operator +, -, *, /, +=, -=, *=, /= and unary - expressions and if the return types are convertible to the expected ones
Rpointer	Checks whether the T denotes a (possibly cv-qualified) pointer type
Rreference	Checks whether the T denotes a reference type
Rdecayed	Checks whether the T denotes a decayed type
Runqualified	Checks whether the T denotes an unqualified type
Rnot_same_as	Checks whether the left-hand-side type is unequal to the right-hand-side type
Rinitializes	Checks whether the target type is constructible from the source type
Rassignable_to	Checks whether the target type is assignable from the source type
Rweakly_equality_comparable	Checks whether the given type is comparable via operator == and !=
Rnothrow_weakly_equality_comparable	Checks whether the given type is comparable via operator == and != and has noexcept specifier
Rweakly_equality_comparable_with	Checks whether a symmetrical set of operators == and != to compare both types with each other exists
Rnothrow_weakly_equality_comparable_with	Checks whether a symmetrical set of operators == and != to compare both types with each other exists and has noexcept specifier
Rcomparison_category	Checks whether the given type denotes a common stl comparison category
Rexplicitly_convertible_to	Checks whether a type is explicit convertible to another
Rnothrow_explicitly_convertible_to	Checks whether a type is explicit convertible to another and does not throw
Rweakly_three_way_comparable	Checks whether the given type is comparable <=> with the minimal comparison category. This also implies equality comparable
Rnothrow_weakly_three_way_comparable	Checks whether the given type is comparable <=> with the minimal comparison category and noexcept specifier. This also implies equality comparable
Rweakly_three_way_comparable_with	Checks whether a symmetrical set of operator <=> to compare both types with each other exists
Rnothrow_weakly_three_way_comparable_with	Checks whether a symmetrical set of operator <=> to compare both types with each other with noexcept specifier exists
Runique_types	Checks whether each given type appears only once in the template argument pack
Rtuple	Determines whether a type can be used as a tuple-like
Rapplicable	Determines whether the function is invocable with the elements of the given tuple
Rnothrow_applicable	Determines whether the function is invocable with the elements of the given tuple without throwing
Rtype_list	Determines whether a type satisfies the requirements of a type-list
Rpopulated_type_list	Determines whether a type is a type-list and contains elements
►Nfunctional
Narithmetic
Ncompare
Ntuple
Nutil
CBasicClosure	The core class, wrapping one functional object and enabling a variety of composing operators for it
Cclosure_template	Primary template, purposely undefined
Cclosure_template< BasicClosure< Fn, InvokePolicy, OperatorPolicies... > >	Specialization, providing the closure template as member alias
CComposition	Functional type, composing multiple other functional types via the provided strategy
CConjunctionOperator
CConjunctionStrategy
CDisjunctionOperator
CDisjunctionStrategy
CEqualityOperator
CEqualityStrategy
Cis_composition	Primary template, yielding false type
Cis_composition< Composition< CompositionStrategy, Fns... > >	Specialization for Composition
CNegationOperator
COverloaded	Helper invocable type which can hold an arbitrary amount of functions, from which the best match will be selected during invocation
CPipeOperator
CPipeStrategy
Cunwrap_functional	Primary template for non BasicClosure types
Cunwrap_functional< BasicClosure< Fn, InvokePolicy, OperatorPolicies... > & >	Specialization for lvalue-references of BasicClosure class
Cunwrap_functional< BasicClosure< Fn, InvokePolicy, OperatorPolicies... > && >	Specialization for rvalue-references of BasicClosure class
Cunwrap_functional< const BasicClosure< Fn, InvokePolicy, OperatorPolicies... > & >	Specialization for const lvalue-references of BasicClosure class
Cunwrap_functional< const BasicClosure< Fn, InvokePolicy, OperatorPolicies... > && >	Specialization for const rvalue-references of BasicClosure class
Rfunction	Determines whether the given type satisfies the constraints of a function type
Rinvoke_policy	Determines whether the given type satisfies the constraints of an invoke-policy
Roperator_policy	Determines whether the given type satisfies the constraints of a operator-policy
Rcomposition_strategy	Determines whether the given type satisfies the requirements of a composition strategy
►Nmath
Cfrexp_result	Result type for the frexp operation
Cmodf_result	Result type for the modf operation
Cremquo_result	Result type for the remquo operation
►Nnullables
Cadapter	A adapter class, mimic the behaviour of nullable types
Cadapter_null_t	Dedicated null type for adapters
CAlgorithm	The core algorithm helper, which executes the held operation when used as the right-hand-side of operator | expressions, when the left-hand-side is a valid nullable type
Cin_place_null_t	Tag type for adapters, which can be used to disambiguate the construction with just a null-object
Ctraits	The main trait, which may be specialized from
Ctraits< adapter< TNull, TAdapted > >	Specialization for raw pointers
Ctraits< std::optional< TArgs... > >	Specialization for std::optional
Ctraits< std::shared_ptr< TArgs... > >	Specialization for std::shared_ptr
Ctraits< std::unique_ptr< TArgs... > >	Specialization for std::unique_ptr
Ctraits< T >	Specialization for raw pointers
Ctraits< unique_handle< T, TDeleteAction > >	Specialization for unique_handle types
Radaptable_with	Determines whether the given adapted and null type satisfy the requirements to be used within a adapter
Rinput_nullable	Checks whether a type is an input_nullable
Rnullable	Checks whether a type is nullable
►Ntuple
Capply_result	Trait type determining the result of a std::apply call
Ccartesian_product_result	Trait type determining the result of a cartesian_product call
Ccat_result	Trait type determining the result of a std::tuple_cat call
Cenvelop_elements_result	Trait type determining the result of a tuple_envelop_elements call
Czip_result	Trait type determining the result of a zip call
►Ntype_list
Cappend	Primary template isn't defined on purpose
Cappend< Container< Elements... >, Types... >	Adds the given types at the end of the source type-list
Cback	Primary template isn't defined on purpose
Cback< Container< Element > >	Specialization retrieving the last element of the source type-list
Cback< Container< First, Others... > >	Specialization investigating the current element of the source type-list
Ccartesian_product_as	Primary template isn't defined on purpose
Ccartesian_product_as< TargetContainer, Container< Elements... > >	Root specialization, enveloping each element of the list in a TargetContainer
Ccartesian_product_as< TargetContainer, Container< Elements... >, OtherLists... >	Specialization, prepending all elements of the current type-list to the already created type-lists
Ccommon_container	Primary template isn't defined on purpose
Ccommon_container< Container< Elements... > >	Unary trait defining the type member-alias
Ccommon_container< Container< LhsElements... >, Container< RhsElements... >, Others... >	Trait reducing the amount of participating type-lists, if the first two have the container in common
Cconcat	Primary template isn't defined on purpose
Cconcat< LhsContainer< LhsElements... >, RhsContainer< RhsElements... >, Others... >	Specialization appending all elements of the second type-list at the back of the first type-list and repeating it for any other not yet investigated type-lists
Cconcat< List >	Unary specialization, simply using the given type-list as result
Ccontains	Primary template isn't defined on purpose
Ccontains< Container< Elements... >, Query >	Specialization determining the presence of the query type, due to comparing it with each element of the type-list
Ccount	Primary template isn't defined on purpose
Ccount< Query, Container< Elements... > >	Specialization counting the presence of the query type, due to comparing it with each element of the type-list
Cdifference_as	Primary template, yielding a the elements of First in the TargetContainer
Cdifference_as< TargetContainer, First, Second >	Specialization, if the front element of Second is not contained in First
Cequal	Primary template yields false
Cequal< First >	Specialization for single type-list
Cequal< FirstContainer< Elements... >, SecondContainer< Elements... >, Others... >	Specialization, determining whether the first two type-lists have equal template arguments
Cfilter	Primary template isn't defined on purpose
Cfilter< Container< Elements... >, Filter >	Applies the filter trait on each element of the source type-list
Cfront	Primary template isn't defined on purpose
Cfront< Container< First, Others... > >	Specialization retrieving the first element of the source type-list
Cindex_of	Primary template, traversing the elements of the source type-list
Cindex_of< List, front_t< List > >	Specialization if the queried type appears at the beginning of the type-list
Cintersection_as	Determines the intersection between the elements of two type-lists. The order doesn't matter
Cpopulated_from	Primary template isn't defined on purpose
Cpopulated_from< TargetContainer, SourceContainer< Elements... > >	Specialization applying each element of the source container as template argument of the target container
Cprepend	Primary template isn't defined on purpose
Cprepend< Container< Elements... >, Types... >	Adds the given types at the begin of the source type-list
Cremove	Applies the filter trait on each element of the source type-list
Cremove_at	Primary template, traversing all elements of the given type-list
Cremove_at< List, 0 >	Root specialization, omitting the first element from the source type-list
Creverse	Reverses the order of all elements
Creverse< Container<> >	Specialization for empty type-lists
Csymmetric_difference_as	Determines which elements are in either of the source type-lists, but not in both. The order doesn't matter
Ctail	Primary template isn't defined on purpose
Ctail< Container< First, Others... > >	Specialization for non-empty source type-lists
Ctail< Container<> >	Specialization for empty source type-lists
Ctransform	Primary template isn't defined on purpose
Ctransform< UnaryOperation, Container< Elements... > >	Specialization, which applies the UnaryOperation on each element of the given type-list
CTypeList	A variadic template type, which's only serves as a container for an arbitrary amount of types. Neither of the given types will be actually instantiated
Cunique	Root specialization for empty type lists
Cunique< List >	Specialization, traversing each element of the given type-list
Cunordered_equal	Primary template isn't defined on purpose
Cunordered_equal< First, OtherLists... >	Specialization, determining whether the current element appears equally often in all type-lists
Cunordered_equal< FirstContainer<>, OtherLists... >	Root specialization, determining whether all type-lists are empty
Czip_as	Algorithm yielding the result as the type member alias
Czip_nth_elements_as	Algorithm yielding the result as the type member alias
Cadd_type_const	Primary template, adding const to value types
Cadd_type_const< T & >	Specialization, unwrapping lvalue reference types
Cadd_type_const< T && >	Specialization, unwrapping rvalue reference types
Cadd_type_const< T * >	Specialization, unwrapping pointer types
Cadd_type_const< T *const >	Specialization, unwrapping const pointer types
Cadd_type_const< T *const volatile >	Specialization, unwrapping const volatile pointer types
Cadd_type_const< T *volatile >	Specialization, unwrapping volatile pointer types
Cadd_type_cv	Primary template, adding const and volatile to value types
Cadd_type_volatile	Primary template, adding volatile to value types
Cadd_type_volatile< T & >	Specialization, unwrapping lvalue reference types
Cadd_type_volatile< T && >	Specialization, unwrapping rvalue reference types
Cadd_type_volatile< T * >	Specialization, unwrapping pointer types
Cadd_type_volatile< T *const >	Specialization, unwrapping const pointer types
Cadd_type_volatile< T *const volatile >	Specialization, unwrapping const volatile pointer types
Cadd_type_volatile< T *volatile >	Specialization, unwrapping volatile pointer types
CCRTPBase	Utility type, which can be used as a base class for the crtp pattern
Ccv_qualified_type	Primary template, taking the T as-is
Ccv_qualified_type< T >	Specialization, unwrapping reference types
Cdefault_delete_action	Default delete action for unique_handle with an empty operator ()
Cnullhandle_t	Helper type for indicating unique_handles with uninitialized state
Cqualified_category_as
Cremove_type_const	Primary template, removing const from value types
Cremove_type_const< T & >	Specialization, unwrapping lvalue reference types
Cremove_type_const< T && >	Specialization, unwrapping rvalue reference types
Cremove_type_const< T * >	Specialization, unwrapping pointer types
Cremove_type_const< T *const >	Specialization, unwrapping const pointer types
Cremove_type_const< T *const volatile >	Specialization, unwrapping const volatile pointer types
Cremove_type_const< T *volatile >	Specialization, unwrapping volatile pointer types
Cremove_type_cv	Primary template, removing const and volatile from value types
Cremove_type_volatile	Primary template, removing volatile from value types
Cremove_type_volatile< T & >	Specialization, unwrapping lvalue reference types
Cremove_type_volatile< T && >	Specialization, unwrapping rvalue reference types
Cremove_type_volatile< T * >	Specialization, unwrapping pointer types
Cremove_type_volatile< T *const >	Specialization, unwrapping const pointer types
Cremove_type_volatile< T *const volatile >	Specialization, unwrapping const volatile pointer types
Cremove_type_volatile< T *volatile >	Specialization, unwrapping volatile pointer types
Ctype_constness_as	Applies or removes the const qualification of To in regards of From
Ctype_qualification_as	Applies or removes the const and/or volatile qualifications of To in regards of From
Ctype_volatileness_as	Applies or removes the volatile qualification of To in regards of From
Cunified_base	Helper type, which can be used to create a unified base class for templated derived classes and thus getting an straight-forward way of disambiguing binary operators
Cunique_handle	This type models some kind of std::optional behaviour but resets itself on move operations
Cvalue_category_as	Primary template, removing any reference category
Cvalue_category_as< To, From & >	Specialization, applying the lvalue reference category
Cvalue_category_as< To, From && >	Specialization, applying the rvalue reference category
Rderived_from_unified_base	Determines whether T is derived of unified_base with the provided tag type
Rvalue	Checks whether the given template type is usable as value type for unique_handle types
Rdelete_action_for	Checks whether the given template type is usable as delete action type for unique_handle types