Trait

Trait invocation/composition. More...

Topics
	Invocation
	Trait invocation.
	Composition
	Trait composition.
	lazy

Classes
struct	meta::id< T >
	A trait that always returns its argument T. More...

Typedefs
template<typename T>
using	meta::id_t = _t<id<T>>
	An alias for type T.
template<typename...>
using	meta::void_ = void
	An alias for void.
template<typename T>
using	meta::is_callable = _t<detail::is_callable_<T>>
	An alias for std::true_type if T::invoke exists and names a class template or alias template; otherwise, it's an alias for std::false_type.
template<typename T>
using	meta::sizeof_ = meta::size_t<sizeof(T)>
	An alias that computes the size of the type T.
template<typename T>
using	meta::alignof_ = meta::size_t<alignof(T)>
	An alias that computes the alignment required for any instance of the type T.
template<typename T, template< typename... > class C>
using	meta::is = _t<detail::is_<T, C>>
	is
template<META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::not_fn = compose<quote<not_>, Fn>
	Logically negate the result of invocable Fn.
template<typename... Ts>
using	meta::lambda = if_c<(sizeof...(Ts) > 0), detail::lambda_<list<Ts...>>>
	For creating anonymous Invocables.
template<typename T>
using	meta::is_valid = detail::is_valid_<T>
	For testing whether a deferred computation will succeed in a let or a lambda.
template<typename... As>
using	meta::let = _t<_t<detail::let_<As...>>>
	A lexically scoped expression with local variables.

Detailed Description

Trait invocation/composition.

Typedef Documentation

alignof_

template<typename T>

using meta::alignof_ = meta::size_t<alignof(T)>

An alias that computes the alignment required for any instance of the type T.

Complexity

O(1).

id_t

template<typename T>

using meta::id_t = _t<id<T>>

An alias for type T.

Useful in non-deduced contexts.

is

template<typename T, template< typename... > class C>

using meta::is = _t<detail::is_<T, C>>

is

Test whether a type T is an instantiation of class template C.

lambda

template<typename... Ts>

using meta::lambda = if_c<(sizeof...(Ts) > 0), detail::lambda_<list<Ts...>>>

For creating anonymous Invocables.

using L = lambda<_a, _b, std::pair<_b, std::pair<_a, _a>>>;
using P = invoke<L, int, short>;
static_assert(std::is_same_v<P, std::pair<short, std::pair<int, int>>>, "");

let

template<typename... As>

using meta::let = _t<_t<detail::let_<As...>>>

A lexically scoped expression with local variables.

template <typename T, typename L>
using find_index_ = let<
    var<_a, L>,
    var<_b, lazy::find<_a, T>>,
    lazy::if_<
        std::is_same<_b, list<>>,
        meta::npos,
        lazy::minus<lazy::size<_a>, lazy::size<_b>>>>;
static_assert(find_index_<int, list<short, int, float>>{} == 1, "");
static_assert(find_index_<double, list<short, int, float>>{} == meta::npos{}, "");

sizeof_

template<typename T>

using meta::sizeof_ = meta::size_t<sizeof(T)>

An alias that computes the size of the type T.

Complexity

O(1).