capy::meta Namespace Reference

Namespaces
namespace	typed__
namespace	valued__
namespace	typed_as_valued__
namespace	valued_as_typed__
namespace	legacy
namespace	implementation_details_

Classes
struct	function_traits
struct	function_traits< ReturnValue_(Params_...) noexcept(IsNoexcept)>
struct	function_traits< ReturnValue_(Class::*)(Params_...) const noexcept(IsNoexcept)>
struct	PackPopHead
struct	PackPopHead< Pack< Head, Tail... > >
struct	functor_ft
struct	functor_fv
struct	Overload
class	Unit
	A zero-cost wrapper for forwarding compile-time type information. More...
class	Pack
	A compile-time heterogeneous type list. More...
class	ValueUnit
	A wrapper for non-type template parameter values. More...
class	UnwrapValueUnit
	Type trait that extracts a value from a ValueUnit. More...
struct	UnwrapValueUnit< ValueUnit< Value > >
	Specialization that extracts the stored value from ValueUnit<Value>. More...
class	UnaryMetaFunction
	A tag for template template parameters representing unary predicates. More...
class	RebindPack
	Type trait that repackages a Pack's elements into a different template. More...
struct	RebindPack< Pack< Elements... >, Template >
	Specialization: extract elements from Pack<Elements...> and apply Template. More...
struct	ConstexprRef
class	RuntimeRef
struct	template_ft
struct	template_fv
struct	Maybe
struct	Maybe< implementation_details_::Nil >
class	KVPair
class	MultyKVPair
class	MetaMap
class	StaticEither
class	StaticEither< Value, Error, implementation_details_::ValueTag >
class	StaticEither< Value, Error, implementation_details_::ErrorTag >
class	StaticMaybe
class	StaticMaybe< Value, implementation_details_::SomeTag >
class	StaticMaybe< Value, implementation_details_::NoneTag >

Concepts
concept	MetaCallable
concept	t_trait
concept	v_trait
concept	wrapped_with
concept	Reference

Typedefs
template<typename Type, template< typename... > typename SrcContainer, template< typename... > typename DstContainer>
using	rebind_t
template<typename Type, template< auto... > typename SrcContainer, template< auto... > typename DstContainer>
using	valued_rebind_t
template<typename Type, template< typename... > typename SrcContainer, template< auto... > typename DstContainer>
using	rebind_typed_as_valued_t
template<typename Type, template< auto... > typename SrcContainer, template< typename... > typename DstContainer>
using	rebind_valued_as_typed_t
template<typename Element, typename Pack>
using	pack_append_t = legacy::append_t<Pack, Element>
template<typename Pack1, typename Pack2>
using	pack_concat_t = legacy::pack_concat_t<Pack1, Pack2>
template<typename... Packs>
using	packs_multy_concat_t = legacy::packs_multy_concat_t<Packs...>
template<typename Pack_, v_trait< MetaArity::N1 > Predicate>
using	pack_filter_t
template<typename Pack, t_trait< MetaArity::N1 > Mapper>
using	pack_filter_map_t
template<typename Pack>
using	pack_head_t = legacy::head_t<Pack>
template<typename Function>
using	return_value_t = typename function_traits<Function>::ReturnValue
template<typename Function>
using	args_pack_t = typename function_traits<Function>::Params
template<typename Pack_, t_trait< MetaArity::N1 > Mapper>
using	pack_map_t
template<typename Pack_>
using	pack_pop_head_t = typename PackPopHead<Pack_>::type
template<typename Pack, typename Element>
using	pack_prepend_t = legacy::prepend_t<Pack, Element>
template<typename Pack1, typename Pack2>
using	pack_zip_t = legacy::pack_zip_t<Pack1, Pack2>
template<typename MetaFunctor, typename... Args>
using	call_t = typename implementation_details_::functor_call_t<MetaFunctor, Args...>::type
template<typename MetaFunctor, MetaArity ARITY>
using	as_nary_ft = fix_template_arity_ft<ARITY, MetaFunctor::template Functor>
template<typename MetaFunctor, MetaArity ARITY>
using	as_nary_fv = fix_template_arity_fv<ARITY, MetaFunctor::template Functor>
template<typename MetaFunctor>
using	as_unary_ft = as_nary_ft<MetaFunctor, MetaArity::N1>
template<typename MetaFunctor>
using	as_unary_fv = as_nary_fv<MetaFunctor, MetaArity::N1>
template<MetaArity ARITY, template< typename... > typename Template>
using	fix_template_arity_ft = typename implementation_details_::FixTemplateArityTyped<ARITY, Template>
template<MetaArity ARITY, template< typename... > typename Template>
using	fix_template_arity_fv = typename implementation_details_::FixTemplateArityValued<ARITY, Template>
template<typename Unit_>
using	unit_inner_type_t = typename Unit_::InnerType
using	EmptyPack = Pack<>
	The empty type pack; useful as a base case for recursive operations.
template<typename Pack_, template< typename... > typename Template>
using	rebind_pack_t = typename RebindPack<Pack_, Template>::type
	Convenience alias for RebindPack.
using	None = Maybe<implementation_details_::Nil>
template<typename T>
using	Some = Maybe<T>
template<typename Value, typename Error>
using	StaticOk = StaticEither<Value, Error, implementation_details_::ValueTag>
template<typename Value, typename Error>
using	StaticError = StaticEither<Value, Error, implementation_details_::ErrorTag>
template<typename Value>
using	StaticNone = StaticMaybe<Value, implementation_details_::NoneTag>

Enumerations
enum class	MetaCallableTag { TYPE_CALLABLE , VALUE_CALLABLE }
enum class	MetaArity {   N1 , N2 , N3 , N4 ,   N5 , N6 , N7 , N8 ,   N9 , N10 , N11 , N12 ,   N13 , N14 , N15 , N16 ,   LINEAR_ARITIES_COUNT }

Functions
template<typename T>
auto	create_static_method_exists_and_is_unique (int *) -> args_pack_t< decltype(T::create)>
template<typename T>
auto	create_static_method_exists_and_is_unique (...) -> int
template<typename Handler, typename... PackElements>
constexpr implementation_details_::valued_pack_for_result_t< Handler, PackElements... >	valued_pack_for (Pack< PackElements... > &&pack, Handler &&handler)
consteval std::optional< MetaArity >	meta_arity_from_args_count (const std::size_t args_count)
template<typename Value>
	StaticMaybe (Value &&) -> StaticMaybe< Value, implementation_details_::SomeTag >

Variables
template<typename Pack_, typename Element>
constexpr bool	pack_contains_t
template<typename Function>
constexpr bool	is_noexcept_v = function_traits<Function>::IS_NOEXCEPT
template<typename T>
constexpr bool	create_static_method_exists_and_is_unique_v
template<typename MetaFunctor, typename... Args>
constexpr auto	call_v = implementation_details_::functor_call_t<MetaFunctor, Args...>::value
constexpr std::size_t	MAX_LINEAR_META_ARITY
template<std::size_t ARGS_COUNT>
constexpr MetaArity	meta_arity_from_args_count_v = meta_arity_from_args_count(ARGS_COUNT).value()
template<typename... Args>
constexpr MetaArity	meta_arity_from_args_v = meta_arity_from_args_count_v<sizeof...(Args)>
template<typename Pack_>
constexpr std::size_t	pack_size_v
template<typename Pack_>
constexpr bool	pack_is_empty_v = pack_size_v<Pack_> == 0

Typedef Documentation

args_pack_t

template<typename Function>

using capy::meta::args_pack_t = typename function_traits<Function>::Params

as_nary_ft

template<typename MetaFunctor, MetaArity ARITY>

using capy::meta::as_nary_ft = fix_template_arity_ft<ARITY, MetaFunctor::template Functor>

as_nary_fv

template<typename MetaFunctor, MetaArity ARITY>

using capy::meta::as_nary_fv = fix_template_arity_fv<ARITY, MetaFunctor::template Functor>

as_unary_ft

template<typename MetaFunctor>

using capy::meta::as_unary_ft = as_nary_ft<MetaFunctor, MetaArity::N1>

as_unary_fv

template<typename MetaFunctor>

using capy::meta::as_unary_fv = as_nary_fv<MetaFunctor, MetaArity::N1>

call_t

template<typename MetaFunctor, typename... Args>

using capy::meta::call_t = typename implementation_details_::functor_call_t<MetaFunctor, Args...>::type

EmptyPack

using capy::meta::EmptyPack = Pack<>

The empty type pack; useful as a base case for recursive operations.

Examples

/capydi/core/capymeta/include/capymeta/primitives/Pack.hpp.

fix_template_arity_ft

template<MetaArity ARITY, template< typename... > typename Template>

using capy::meta::fix_template_arity_ft = typename implementation_details_::FixTemplateArityTyped<ARITY, Template>

fix_template_arity_fv

template<MetaArity ARITY, template< typename... > typename Template>

using capy::meta::fix_template_arity_fv = typename implementation_details_::FixTemplateArityValued<ARITY, Template>

None

using capy::meta::None = Maybe<implementation_details_::Nil>

pack_append_t

template<typename Element, typename Pack>

using capy::meta::pack_append_t = legacy::append_t<Pack, Element>

pack_concat_t

template<typename Pack1, typename Pack2>

using capy::meta::pack_concat_t = legacy::pack_concat_t<Pack1, Pack2>

pack_filter_map_t

template<typename Pack, t_trait< MetaArity::N1 > Mapper>

using capy::meta::pack_filter_map_t

Initial value:

 legacy::filter_map_t<
    Pack,
    as_unary_ft<Mapper>::template Functor
>

pack_filter_t

template<typename Pack_, v_trait< MetaArity::N1 > Predicate>

using capy::meta::pack_filter_t

Initial value:

 legacy::filter_t<
        Pack_,
        as_unary_fv<Predicate>::template Functor
    >

pack_head_t

template<typename Pack>

using capy::meta::pack_head_t = legacy::head_t<Pack>

pack_map_t

template<typename Pack_, t_trait< MetaArity::N1 > Mapper>

using capy::meta::pack_map_t

Initial value:

 legacy::pack_map_t<
        Pack_,
        as_unary_ft<Mapper>::template Functor
    >

pack_pop_head_t

template<typename Pack_>

using capy::meta::pack_pop_head_t = typename PackPopHead<Pack_>::type

pack_prepend_t

template<typename Pack, typename Element>

using capy::meta::pack_prepend_t = legacy::prepend_t<Pack, Element>

pack_zip_t

template<typename Pack1, typename Pack2>

using capy::meta::pack_zip_t = legacy::pack_zip_t<Pack1, Pack2>

packs_multy_concat_t

template<typename... Packs>

using capy::meta::packs_multy_concat_t = legacy::packs_multy_concat_t<Packs...>

rebind_pack_t

template<typename Pack_, template< typename... > typename Template>

using capy::meta::rebind_pack_t = typename RebindPack<Pack_, Template>::type

Convenience alias for RebindPack.

Examples

/capydi/core/capymeta/include/capymeta/primitives/Pack.hpp.

rebind_t

template<typename Type, template< typename... > typename SrcContainer, template< typename... > typename DstContainer>

using capy::meta::rebind_t

Initial value:

 typename typed__::Rebind<
    Type, 
    SrcContainer, 
    DstContainer
>::type

rebind_typed_as_valued_t

template<typename Type, template< typename... > typename SrcContainer, template< auto... > typename DstContainer>

using capy::meta::rebind_typed_as_valued_t

Initial value:

 typename typed_as_valued__::Rebind<
    Type, 
    SrcContainer, 
    DstContainer
>::type

rebind_valued_as_typed_t

template<typename Type, template< auto... > typename SrcContainer, template< typename... > typename DstContainer>

using capy::meta::rebind_valued_as_typed_t

Initial value:

 typename valued_as_typed__::Rebind<
    Type, 
    SrcContainer, 
    DstContainer
>::type

return_value_t

template<typename Function>

using capy::meta::return_value_t = typename function_traits<Function>::ReturnValue

Some

template<typename T>

using capy::meta::Some = Maybe<T>

StaticError

template<typename Value, typename Error>

using capy::meta::StaticError = StaticEither<Value, Error, implementation_details_::ErrorTag>

StaticNone

template<typename Value>

using capy::meta::StaticNone = StaticMaybe<Value, implementation_details_::NoneTag>

StaticOk

template<typename Value, typename Error>

using capy::meta::StaticOk = StaticEither<Value, Error, implementation_details_::ValueTag>

unit_inner_type_t

template<typename Unit_>

using capy::meta::unit_inner_type_t = typename Unit_::InnerType

Examples

/capydi/core/capymeta/include/capymeta/primitives/Pack.hpp.

valued_rebind_t

template<typename Type, template< auto... > typename SrcContainer, template< auto... > typename DstContainer>

using capy::meta::valued_rebind_t

Initial value:

 typename valued__::Rebind<
    Type, 
    SrcContainer, 
    DstContainer
>::type

Enumeration Type Documentation

MetaArity

enum class capy::meta::MetaArity

strong

Enumerator
N1
N2
N3
N4
N5
N6
N7
N8
N9
N10
N11
N12
N13
N14
N15
N16
LINEAR_ARITIES_COUNT

MetaCallableTag

enum class capy::meta::MetaCallableTag

strong

Enumerator
TYPE_CALLABLE
VALUE_CALLABLE

Function Documentation

create_static_method_exists_and_is_unique() [1/2]

template<typename T>

auto capy::meta::create_static_method_exists_and_is_unique

(

...

)

->int

create_static_method_exists_and_is_unique() [2/2]

template<typename T>

auto capy::meta::create_static_method_exists_and_is_unique

(

int *

)

->args_pack_t< decltype(T::create)>

meta_arity_from_args_count()

std::optional< MetaArity > capy::meta::meta_arity_from_args_count ( const std::size_t args_count )

consteval

StaticMaybe()

template<typename Value>

capy::meta::StaticMaybe

(

Value &&

)

->StaticMaybe< Value, implementation_details_::SomeTag >

valued_pack_for()

template<typename Handler, typename... PackElements>

implementation_details_::valued_pack_for_result_t< Handler, PackElements... > capy::meta::valued_pack_for ( Pack< PackElements... > && pack, Handler && handler )

constexpr

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

call_v

template<typename MetaFunctor, typename... Args>

auto capy::meta::call_v = implementation_details_::functor_call_t<MetaFunctor, Args...>::value

constexpr

create_static_method_exists_and_is_unique_v

template<typename T>

bool capy::meta::create_static_method_exists_and_is_unique_v

constexpr

Initial value:

= !std::same_as<
    decltype(create_static_method_exists_and_is_unique<T>(nullptr)),
    int
>

is_noexcept_v

template<typename Function>

bool capy::meta::is_noexcept_v = function_traits<Function>::IS_NOEXCEPT

constexpr

MAX_LINEAR_META_ARITY

std::size_t capy::meta::MAX_LINEAR_META_ARITY

constexpr

Initial value:

= static_cast<std::size_t>(
    MetaArity::LINEAR_ARITIES_COUNT
)

meta_arity_from_args_count_v

template<std::size_t ARGS_COUNT>

MetaArity capy::meta::meta_arity_from_args_count_v = meta_arity_from_args_count(ARGS_COUNT).value()

constexpr

meta_arity_from_args_v

template<typename... Args>

MetaArity capy::meta::meta_arity_from_args_v = meta_arity_from_args_count_v<sizeof...(Args)>

constexpr

pack_contains_t

template<typename Pack_, typename Element>

bool capy::meta::pack_contains_t

constexpr

Initial value:

= !pack_is_empty_v<pack_filter_t<
    Pack_,
    functor_fv<[]<class T>(Pack<T>) {
        return std::same_as<T, Element>;
    }, MetaArity::N1>
>>

pack_is_empty_v

template<typename Pack_>

bool capy::meta::pack_is_empty_v = pack_size_v<Pack_> == 0

constexpr

Examples

/capydi/core/capymeta/include/capymeta/primitives/Pack.hpp.

pack_size_v

template<typename Pack_>

std::size_t capy::meta::pack_size_v

constexpr

Initial value:

= []<typename... Types>(Pack<Types...>&&) {
    return sizeof...(Types);
}(Pack_{})

Examples

/capydi/core/capymeta/include/capymeta/primitives/Pack.hpp.