meta.hpp File Reference

Tiny meta-programming library. More...

#include <cstddef>
#include <initializer_list>
#include <meta/meta_fwd.hpp>
#include <type_traits>
#include <utility>

Go to the source code of this file.

Classes
struct	meta::nil_
	An empty type. More...
struct	meta::integer_sequence< T, Is >
	A container for a sequence of compile-time integer constants. More...
struct	meta::id< T >
	A trait that always returns its argument T. More...
struct	meta::defer< C, Ts >
	A wrapper that defers the instantiation of a template C with type parameters Ts in a lambda or let expression. More...
struct	meta::defer_i< T, C, Is >
	A wrapper that defers the instantiation of a template C with integral constant parameters Is in a lambda or let expression. More...
struct	meta::compose_< Fns >
	Compose the Invocables Fns in the parameter pack Ts. More...
struct	meta::compose_< Fn0 >
struct	meta::compose_< Fn0, Fns... >
struct	meta::quote< C >
	Turn a template C into an invocable. More...
struct	meta::quote_i< T, C >
	Turn a template C taking literals of type T into a invocable. More...
struct	meta::bind_front< Fn, Ts >
	An invocable that partially applies the invocable Fn by binding the arguments Ts to the front of Fn. More...
struct	meta::bind_back< Fn, Us >
	An invocable that partially applies the invocable Fn by binding the arguments Us to the back of Fn. More...
struct	meta::extension::apply< Fn, L >
	A trait that unpacks the types in the type list L into the invocable Fn. More...
struct	meta::extension::apply< Fn, Ret(Args...)>
struct	meta::extension::apply< Fn, T< Ts... > >
struct	meta::extension::apply< Fn, integer_sequence< T, Is... > >
struct	meta::flip< Fn >
	An invocable that reverses the order of the first two arguments. More...
struct	meta::and_c< Bs >
struct	meta::or_c< Bs >
	Logically OR together all the Boolean parameters. More...
struct	meta::list< Ts >
	A list of types. More...
struct	meta::detail::count_< typename, typename >
struct	meta::detail::count_< list<>, T >
struct	meta::detail::count_< list< L... >, T >
struct	meta::detail::count_if_< L, Fn, typename >
struct	meta::detail::count_if_< list<>, Fn >
struct	meta::detail::count_if_< list< L... >, Fn, void_< integer_sequence< bool, bool(invoke< Fn, L >::type::value)... > > >

Namespaces
namespace	meta
	Tiny metaprogramming library.
namespace	meta::lazy
	Lazy versions of meta actions.
namespace	meta::extension
	Extend meta with your own datatypes.

Typedefs
template<META_TYPE_CONSTRAINT(trait) T>
using	meta::_t = typename T::type
	Type alias for T::type.
template<typename T>
using	meta::lazy::_t = defer<_t, T>
template<std::size_t N>
using	meta::size_t = std::integral_constant<std::size_t, N>
	An integral constant wrapper for std::size_t.
template<bool B>
using	meta::bool_ = std::integral_constant<bool, B>
	An integral constant wrapper for bool.
template<int I>
using	meta::int_ = std::integral_constant<int, I>
	An integral constant wrapper for int.
template<char Ch>
using	meta::char_ = std::integral_constant<char, Ch>
	An integral constant wrapper for char.
template<META_TYPE_CONSTRAINT(integral) T>
using	meta::inc = std::integral_constant<decltype(T::type::value + 1), T::type::value + 1>
	An integral constant wrapper around the result of incrementing the wrapped integer T::type::value.
template<META_TYPE_CONSTRAINT(integral) T>
using	meta::dec = std::integral_constant<decltype(T::type::value - 1), T::type::value - 1>
	An integral constant wrapper around the result of decrementing the wrapped integer T::type::value.
template<META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
using	meta::plus
	An integral constant wrapper around the result of adding the two wrapped integers T::type::value and U::type::value.
template<META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
using	meta::minus
	An integral constant wrapper around the result of subtracting the two wrapped integers T::type::value and U::type::value.
template<META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
using	meta::multiplies
	An integral constant wrapper around the result of multiplying the two wrapped integers T::type::value and U::type::value.
template<META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
using	meta::divides
	An integral constant wrapper around the result of dividing the two wrapped integers T::type::value and U::type::value.
template<META_TYPE_CONSTRAINT(integral) T>
using	meta::negate = std::integral_constant<decltype(-T::type::value), -T::type::value>
	An integral constant wrapper around the result of negating the wrapped integer T::type::value.
template<META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
using	meta::modulus
	An integral constant wrapper around the remainder of dividing the two wrapped integers T::type::value and U::type::value.
template<META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
using	meta::equal_to = bool_<T::type::value == U::type::value>
	A Boolean integral constant wrapper around the result of comparing T::type::value and U::type::value for equality.
template<META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
using	meta::not_equal_to = bool_<T::type::value != U::type::value>
	A Boolean integral constant wrapper around the result of comparing T::type::value and U::type::value for inequality.
template<META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
using	meta::greater = bool_<(T::type::value > U::type::value)>
	A Boolean integral constant wrapper around true if T::type::value is greater than U::type::value; false, otherwise.
template<META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
using	meta::less = bool_<(T::type::value < U::type::value)>
	A Boolean integral constant wrapper around true if T::type::value is less than U::type::value; false, otherwise.
template<META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
using	meta::greater_equal = bool_<(T::type::value >= U::type::value)>
	A Boolean integral constant wrapper around true if T::type::value is greater than or equal to U::type::value; false, otherwise.
template<META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
using	meta::less_equal = bool_<(T::type::value <= U::type::value)>
	A Boolean integral constant wrapper around true if T::type::value is less than or equal to U::type::value; false, otherwise.
template<META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
using	meta::bit_and
	An integral constant wrapper around the result of bitwise-and'ing the two wrapped integers T::type::value and U::type::value.
template<META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
using	meta::bit_or
	An integral constant wrapper around the result of bitwise-or'ing the two wrapped integers T::type::value and U::type::value.
template<META_TYPE_CONSTRAINT(integral) T, META_TYPE_CONSTRAINT(integral) U>
using	meta::bit_xor
	An integral constant wrapper around the result of bitwise-exclusive-or'ing the two wrapped integers T::type::value and U::type::value.
template<META_TYPE_CONSTRAINT(integral) T>
using	meta::bit_not = std::integral_constant<decltype(~T::type::value), ~T::type::value>
	An integral constant wrapper around the result of bitwise-complementing the wrapped integer T::type::value.
template<typename T>
using	meta::lazy::inc = defer<inc, T>
template<typename T>
using	meta::lazy::dec = defer<dec, T>
template<typename T, typename U>
using	meta::lazy::plus = defer<plus, T, U>
template<typename T, typename U>
using	meta::lazy::minus = defer<minus, T, U>
template<typename T, typename U>
using	meta::lazy::multiplies = defer<multiplies, T, U>
template<typename T, typename U>
using	meta::lazy::divides = defer<divides, T, U>
template<typename T>
using	meta::lazy::negate = defer<negate, T>
template<typename T, typename U>
using	meta::lazy::modulus = defer<modulus, T, U>
template<typename T, typename U>
using	meta::lazy::equal_to = defer<equal_to, T, U>
template<typename T, typename U>
using	meta::lazy::not_equal_to = defer<not_equal_to, T, U>
template<typename T, typename U>
using	meta::lazy::greater = defer<greater, T, U>
template<typename T, typename U>
using	meta::lazy::less = defer<less, T, U>
template<typename T, typename U>
using	meta::lazy::greater_equal = defer<greater_equal, T, U>
template<typename T, typename U>
using	meta::lazy::less_equal = defer<less_equal, T, U>
template<typename T, typename U>
using	meta::lazy::bit_and = defer<bit_and, T, U>
template<typename T, typename U>
using	meta::lazy::bit_or = defer<bit_or, T, U>
template<typename T, typename U>
using	meta::lazy::bit_xor = defer<bit_xor, T, U>
template<typename T>
using	meta::lazy::bit_not = defer<bit_not, T>
template<std::size_t... Is>
using	meta::index_sequence = integer_sequence<std::size_t, Is...>
	A container for a sequence of compile-time integer constants of type std::size_t.
template<std::size_t N>
using	meta::make_index_sequence
	Generate index_sequence containing integer constants [0,1,2,...,N-1].
template<typename T, T N>
using	meta::make_integer_sequence
	Generate integer_sequence containing integer constants [0,1,2,...,N-1].
template<typename T, T From, T To>
using	meta::integer_range
	Makes the integer sequence [From, To).
template<META_TYPE_CONSTRAINT(invocable) Fn, typename... Args>
using	meta::invoke = typename Fn::template invoke<Args...>
	Evaluate the invocable Fn with the arguments Args.
template<typename Fn, typename... Args>
using	meta::lazy::invoke = defer<invoke, Fn, Args...>
template<typename T>
using	meta::id_t = _t<id<T>>
	An alias for type T.
template<typename T>
using	meta::lazy::id = defer<id, T>
template<typename...>
using	meta::void_ = void
	An alias for void.
template<typename T>
using	meta::is_trait = _t<detail::is_trait_<T>>
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<template< typename... > class C, typename... Ts>
using	meta::defer_trait = defer<detail::_t_t, detail::defer_<C, Ts...>>
	A wrapper that defers the instantiation of a trait C with type parameters Ts in a lambda or let expression.
template<typename T, template< T... > class C, T... Is>
using	meta::defer_trait_i = defer<detail::_t_t, detail::defer_i_<T, C, Is...>>
	A wrapper that defers the instantiation of a trait C with integral constant parameters Is in a lambda or let expression.
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>
using	meta::lazy::sizeof_ = defer<sizeof_, T>
template<typename T>
using	meta::lazy::alignof_ = defer<alignof_, T>
template<typename T, template< typename... > class C>
using	meta::is = _t<detail::is_<T, C>>
	is
template<typename... Fns>
using	meta::compose = compose_<Fns...>
template<typename... Fns>
using	meta::lazy::compose = defer<compose, Fns...>
template<template< typename... > class C>
using	meta::quote_trait = compose<quote<_t>, quote<C>>
	Turn a trait template C into an invocable.
template<typename T, template< T... > class C>
using	meta::quote_trait_i = compose<quote<_t>, quote_i<T, C>>
	Turn a trait template C taking literals of type T into an invocable.
template<typename Fn, typename... Ts>
using	meta::lazy::bind_front = defer<bind_front, Fn, Ts...>
template<typename Fn, typename... Ts>
using	meta::lazy::bind_back = defer<bind_back, Fn, Ts...>
template<META_TYPE_CONSTRAINT(invocable) Fn, typename L>
using	meta::apply = _t<extension::apply<Fn, L>>
	Applies the invocable Fn using the types in the type list L as arguments.
template<typename Fn, typename L>
using	meta::lazy::apply = defer<apply, Fn, L>
template<META_TYPE_CONSTRAINT(invocable) Fn, META_TYPE_CONSTRAINT(invocable) Q = quote<list>>
using	meta::curry = compose<Fn, Q>
	An invocable that takes a bunch of arguments, bundles them into a type list, and then calls the invocable Fn with the type list Q.
template<META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::uncurry = bind_front<quote<apply>, Fn>
	An invocable that takes a type list, unpacks the types, and then calls the invocable Fn with the types.
template<typename Fn, typename Q = quote<list>>
using	meta::lazy::curry = defer<curry, Fn, Q>
template<typename Fn>
using	meta::lazy::uncurry = defer<uncurry, Fn>
template<typename Fn>
using	meta::lazy::flip = defer<flip, Fn>
template<META_TYPE_CONSTRAINT(invocable)... Fns>
using	meta::on_ = detail::on_<Fns...>
	Use as on<Fn, Gs...>.
template<typename... Fns>
using	meta::on = on_<Fns...>
template<typename Fn, typename G>
using	meta::lazy::on = defer<on, Fn, G>
template<bool If, typename Then, typename Else = void>
using	meta::conditional_t = typename detail::_cond<If>::template invoke<Then, Else>
	Select one type or another depending on a compile-time Boolean.
template<typename... Args>
using	meta::if_ = _t<detail::_if_<list<Args...>>>
	Select one type or another depending on a compile-time Boolean.
template<bool If, typename... Args>
using	meta::if_c = _t<detail::_if_<list<bool_<If>, Args...>>>
template<typename... Args>
using	meta::lazy::if_ = defer<if_, Args...>
template<bool If, typename... Args>
using	meta::lazy::if_c = if_<bool_<If>, Args...>
template<bool B>
using	meta::not_c = bool_<!B>
	Logically negate the Boolean parameter.
template<META_TYPE_CONSTRAINT(integral) B>
using	meta::not_ = not_c<B::type::value>
	Logically negate the integral constant-wrapped Boolean parameter.
template<META_TYPE_CONSTRAINT(integral)... Bs>
using	meta::strict_and_ = and_c<Bs::type::value...>
	Logically AND together all the integral constant-wrapped Boolean parameters, without short-circuiting.
template<typename... Bs>
using	meta::strict_and = strict_and_<Bs...>
template<typename... Bs>
using	meta::and_ = _t<defer<detail::_and_<0 == sizeof...(Bs)>::template invoke, Bs...>>
	Logically AND together all the integral constant-wrapped Boolean parameters, with short-circuiting.
template<META_TYPE_CONSTRAINT(integral)... Bs>
using	meta::strict_or_ = or_c<Bs::type::value...>
	Logically OR together all the integral constant-wrapped Boolean parameters, without short-circuiting.
template<typename... Bs>
using	meta::strict_or = strict_or_<Bs...>
template<typename... Bs>
using	meta::or_ = _t<defer<detail::_or_<0 == sizeof...(Bs)>::template invoke, Bs...>>
	Logically OR together all the integral constant-wrapped Boolean parameters, with short-circuiting.
template<typename... Bs>
using	meta::lazy::and_ = defer<and_, Bs...>
template<typename... Bs>
using	meta::lazy::or_ = defer<or_, Bs...>
template<typename B>
using	meta::lazy::not_ = defer<not_, B>
template<typename... Bs>
using	meta::lazy::strict_and = defer<strict_and, Bs...>
template<typename... Bs>
using	meta::lazy::strict_or = defer<strict_or, Bs...>
template<META_TYPE_CONSTRAINT(list_like) L, typename State, META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::fold = _t<detail::fold_<L, id<State>, Fn>>
	Return a new meta::list constructed by doing a left fold of the list L using binary invocable Fn and initial state State.
template<META_TYPE_CONSTRAINT(list_like) L, typename State, META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::accumulate = fold<L, State, Fn>
	An alias for meta::fold.
template<typename L, typename State, typename Fn>
using	meta::lazy::fold = defer<fold, L, State, Fn>
template<typename L, typename State, typename Fn>
using	meta::lazy::accumulate = defer<accumulate, L, State, Fn>
template<META_TYPE_CONSTRAINT(list_like) L, typename State, META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::reverse_fold = _t<detail::reverse_fold_<L, State, Fn>>
	Return a new meta::list constructed by doing a right fold of the list L using binary invocable Fn and initial state State.
template<typename L, typename State, typename Fn>
using	meta::lazy::reverse_fold = defer<reverse_fold, L, State, Fn>
using	meta::npos = meta::size_t<std::size_t(-1)>
	A special value used to indicate no matches.
template<META_TYPE_CONSTRAINT(list_like) L>
using	meta::size = meta::size_t<L::size()>
	An integral constant wrapper that is the size of the meta::list L.
template<typename L>
using	meta::lazy::size = defer<size, L>
template<META_TYPE_CONSTRAINT(list_like)... Ls>
using	meta::concat_ = _t<detail::concat_<Ls...>>
	Concatenates several lists into a single list.
template<typename... Lists>
using	meta::concat = concat_<Lists...>
template<typename... Lists>
using	meta::lazy::concat = defer<concat, Lists...>
template<META_TYPE_CONSTRAINT(list_like) ListOfLists>
using	meta::join = apply<quote<concat>, ListOfLists>
	Joins a list of lists into a single list.
template<typename ListOfLists>
using	meta::lazy::join = defer<join, ListOfLists>
template<typename... Args>
using	meta::transform = _t<detail::transform_<list<Args...>>>
	Return a new meta::list constructed by transforming all the elements in L with the unary invocable Fn.
template<typename... Args>
using	meta::lazy::transform = defer<transform, Args...>
template<std::size_t N, typename T = void>
using	meta::repeat_n_c = _t<detail::repeat_n_c_<T, make_index_sequence<N>>>
	Generate list<T,T,T...T> of size N arguments.
template<META_TYPE_CONSTRAINT(integral) N, typename T = void>
using	meta::repeat_n = repeat_n_c<N::type::value, T>
	Generate list<T,T,T...T> of size N arguments.
template<typename N, typename T = void>
using	meta::lazy::repeat_n = defer<repeat_n, N, T>
template<std::size_t N, typename T = void>
using	meta::lazy::repeat_n_c = defer<repeat_n, meta::size_t<N>, T>
template<META_TYPE_CONSTRAINT(list_like) L, std::size_t N>
using	meta::at_c = _t<detail::at_<L, N>>
	Return the N th element in the meta::list L.
template<META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(integral) N>
using	meta::at = at_c<L, N::type::value>
	Return the N th element in the meta::list L.
template<typename L, typename N>
using	meta::lazy::at = defer<at, L, N>
template<META_TYPE_CONSTRAINT(list_like) L, std::size_t N>
using	meta::drop_c = _t<detail::drop_<L, N>>
	Return a new meta::list by removing the first N elements from L.
template<META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(integral) N>
using	meta::drop = drop_c<L, N::type::value>
	Return a new meta::list by removing the first N elements from L.
template<typename L, typename N>
using	meta::lazy::drop = defer<drop, L, N>
template<META_TYPE_CONSTRAINT(list_like) L>
using	meta::front = _t<detail::front_<L>>
	Return the first element in meta::list L.
template<typename L>
using	meta::lazy::front = defer<front, L>
template<META_TYPE_CONSTRAINT(list_like) L>
using	meta::back = _t<detail::back_<L>>
	Return the last element in meta::list L.
template<typename L>
using	meta::lazy::back = defer<back, L>
template<META_TYPE_CONSTRAINT(list_like) L, typename... Ts>
using	meta::push_front = apply<bind_front<quote<list>, Ts...>, L>
	Return a new meta::list by adding the element T to the front of L.
template<typename... Ts>
using	meta::lazy::push_front = defer<push_front, Ts...>
template<META_TYPE_CONSTRAINT(list_like) L>
using	meta::pop_front = _t<detail::pop_front_<L>>
	Return a new meta::list by removing the first element from the front of L.
template<typename L>
using	meta::lazy::pop_front = defer<pop_front, L>
template<META_TYPE_CONSTRAINT(list_like) L, typename... Ts>
using	meta::push_back = apply<bind_back<quote<list>, Ts...>, L>
	Return a new meta::list by adding the element T to the back of L.
template<typename... Ts>
using	meta::lazy::push_back = defer<push_back, Ts...>
template<META_TYPE_CONSTRAINT(integral)... Ts>
using	meta::min_ = fold<pop_front<list<Ts...>>, front<list<Ts...>>, quote<detail::min_>>
	An integral constant wrapper around the minimum of Ts::type::value....
template<typename... Ts>
using	meta::min = min_<Ts...>
template<META_TYPE_CONSTRAINT(integral)... Ts>
using	meta::max_ = fold<pop_front<list<Ts...>>, front<list<Ts...>>, quote<detail::max_>>
	An integral constant wrapper around the maximum of Ts::type::value....
template<typename... Ts>
using	meta::max = max_<Ts...>
template<typename... Ts>
using	meta::lazy::min = defer<min, Ts...>
template<typename... Ts>
using	meta::lazy::max = defer<max, Ts...>
template<META_TYPE_CONSTRAINT(list_like) L>
using	meta::empty = bool_<0 == size<L>::type::value>
	An Boolean integral constant wrapper around true if L is an empty type list; false, otherwise.
template<typename L>
using	meta::lazy::empty = defer<empty, L>
template<typename F, typename S>
using	meta::pair = list<F, S>
	A list with exactly two elements.
template<typename Pair>
using	meta::first = front<Pair>
	Retrieve the first element of the pair Pair.
template<typename Pair>
using	meta::second = front<pop_front<Pair>>
	Retrieve the first element of the pair Pair.
template<typename Pair>
using	meta::lazy::first = defer<first, Pair>
template<typename Pair>
using	meta::lazy::second = defer<second, Pair>
template<META_TYPE_CONSTRAINT(list_like) L, typename T>
using	meta::find_index = _t<detail::find_index_<L, T>>
	Finds the index of the first occurrence of the type T within the list L.
template<typename L, typename T>
using	meta::lazy::find_index = defer<find_index, L, T>
template<META_TYPE_CONSTRAINT(list_like) L, typename T>
using	meta::reverse_find_index = _t<detail::reverse_find_index_<L, T>>
	Finds the index of the last occurrence of the type T within the list L.
template<typename L, typename T>
using	meta::lazy::reverse_find_index = defer<reverse_find_index, L, T>
template<META_TYPE_CONSTRAINT(list_like) L, typename T>
using	meta::find = drop<L, min<find_index<L, T>, size<L>>>
	Return the tail of the list L starting at the first occurrence of T, if any such element exists; the empty list, otherwise.
template<typename L, typename T>
using	meta::lazy::find = defer<find, L, T>
template<META_TYPE_CONSTRAINT(list_like) L, typename T>
using	meta::reverse_find = drop<L, min<reverse_find_index<L, T>, size<L>>>
	Return the tail of the list L starting at the last occurrence of T, if any such element exists; the empty list, otherwise.
template<typename L, typename T>
using	meta::lazy::reverse_find = defer<reverse_find, L, T>
template<META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::find_if = _t<detail::find_if_<L, Fn>>
	Return the tail of the list L starting at the first element A such that invoke<Fn, A>::value is true, if any such element exists; the empty list, otherwise.
template<typename L, typename Fn>
using	meta::lazy::find_if = defer<find_if, L, Fn>
template<META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::reverse_find_if = _t<detail::reverse_find_if_<L, Fn>>
	Return the tail of the list L starting at the last element A such that invoke<Fn, A>::value is true, if any such element exists; the empty list, otherwise.
template<typename L, typename Fn>
using	meta::lazy::reverse_find_if = defer<reverse_find_if, L, Fn>
template<META_TYPE_CONSTRAINT(list_like) L, typename T, typename U>
using	meta::replace = _t<detail::replace_<L, T, U>>
	Return a new meta::list where all instances of type T have been replaced with U.
template<typename L, typename T, typename U>
using	meta::lazy::replace = defer<replace, T, U>
template<META_TYPE_CONSTRAINT(list_like) L, typename C, typename U>
using	meta::replace_if = _t<detail::replace_if_<L, C, U>>
	Return a new meta::list where all elements A of the list L for which invoke<C,A>::value is true have been replaced with U.
template<typename L, typename C, typename U>
using	meta::lazy::replace_if = defer<replace_if, C, U>
template<META_TYPE_CONSTRAINT(list_like) L, typename T>
using	meta::count = _t<detail::count_<L, T>>
	Count the number of times a type T appears in the list L.
template<typename L, typename T>
using	meta::lazy::count = defer<count, L, T>
template<META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::count_if = _t<detail::count_if_<L, Fn>>
	Count the number of times the predicate Fn evaluates to true for all the elements in the list L.
template<typename L, typename Fn>
using	meta::lazy::count_if = defer<count_if, L, Fn>
template<typename L, typename Pred>
using	meta::filter = join<transform<L, detail::filter_<Pred>>>
	Returns a new meta::list where only those elements of L that satisfy the Callable Pred such that invoke<Pred,A>::value is true are present.
template<typename L, typename Fn>
using	meta::lazy::filter = defer<filter, L, Fn>
template<META_TYPE_CONSTRAINT(list_like) ListOfLists>
using	meta::transpose
	Given a list of lists of types ListOfLists, transpose the elements from the lists.
template<typename ListOfLists>
using	meta::lazy::transpose = defer<transpose, ListOfLists>
template<META_TYPE_CONSTRAINT(invocable) Fn, META_TYPE_CONSTRAINT(list_like) ListOfLists>
using	meta::zip_with = transform<transpose<ListOfLists>, uncurry<Fn>>
	Given a list of lists of types ListOfLists and an invocable Fn, construct a new list by calling Fn with the elements from the lists pairwise.
template<typename Fn, typename ListOfLists>
using	meta::lazy::zip_with = defer<zip_with, Fn, ListOfLists>
template<META_TYPE_CONSTRAINT(list_like) ListOfLists>
using	meta::zip = transpose<ListOfLists>
	Given a list of lists of types ListOfLists, construct a new list by grouping the elements from the lists pairwise into meta::lists.
template<typename ListOfLists>
using	meta::lazy::zip = defer<zip, ListOfLists>
template<typename Sequence>
using	meta::as_list = _t<detail::as_list_<detail::uncvref_t<Sequence>>>
	Turn a type into an instance of meta::list in a way determined by meta::apply.
template<typename Sequence>
using	meta::lazy::as_list = defer<as_list, Sequence>
template<META_TYPE_CONSTRAINT(list_like) L>
using	meta::reverse = _t<detail::reverse_<L>>
	Return a new meta::list by reversing the elements in the list L.
template<typename L>
using	meta::lazy::reverse = defer<reverse, L>
template<META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::not_fn = compose<quote<not_>, Fn>
	Logically negate the result of invocable Fn.
template<typename Fn>
using	meta::lazy::not_fn = defer<not_fn, Fn>
template<META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::all_of = empty<find_if<L, not_fn<Fn>>>
	A Boolean integral constant wrapper around true if invoke<Fn, A>::value is true for all elements A in meta::list L; false, otherwise.
template<typename L, typename Fn>
using	meta::lazy::all_of = defer<all_of, L, Fn>
template<META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::any_of = not_<empty<find_if<L, Fn>>>
	A Boolean integral constant wrapper around true if invoke<Fn, A>::value is true for any element A in meta::list L; false, otherwise.
template<typename L, typename Fn>
using	meta::lazy::any_of = defer<any_of, L, Fn>
template<META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::none_of = empty<find_if<L, Fn>>
	A Boolean integral constant wrapper around true if invoke<Fn, A>::value is false for all elements A in meta::list L; false, otherwise.
template<typename L, META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::lazy::none_of = defer<none_of, L, Fn>
template<META_TYPE_CONSTRAINT(list_like) L, typename T>
using	meta::in = not_<empty<find<L, T>>>
	A Boolean integral constant wrapper around true if there is at least one occurrence of T in L.
template<typename L, typename T>
using	meta::lazy::in = defer<in, L, T>
template<META_TYPE_CONSTRAINT(list_like) L>
using	meta::inherit = meta::_t<detail::inherit_<L>>
	A type that inherits from all the types in the list.
template<typename L>
using	meta::lazy::inherit = defer<inherit, L>
template<META_TYPE_CONSTRAINT(list_like) L>
using	meta::unique = fold<L, list<>, quote_trait<detail::insert_back_>>
	Return a new meta::list where all duplicate elements have been removed.
template<typename L>
using	meta::lazy::unique = defer<unique, L>
template<META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::partition = fold<L, pair<list<>, list<>>, detail::partition_<Fn>>
	Returns a pair of lists, where the elements of L that satisfy the invocable Fn such that invoke<Fn,A>::value is true are present in the first list and the rest are in the second.
template<typename L, typename Fn>
using	meta::lazy::partition = defer<partition, L, Fn>
template<META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
using	meta::sort = _t<detail::sort_<L, Fn>>
	Return a new meta::list that is sorted according to invocable predicate Fn.
template<typename L, typename Fn>
using	meta::lazy::sort = defer<sort, L, 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 T>
using	meta::vararg = detail::vararg_<T>
	For defining variadic placeholders.
template<typename T>
using	meta::protect = detail::protect_<T>
	For preventing the evaluation of a nested defered computation in a let or lambda expression.
template<typename... As>
using	meta::let = _t<_t<detail::let_<As...>>>
	A lexically scoped expression with local variables.
template<typename... As>
using	meta::lazy::let = defer<let, As...>
using	meta::_args = vararg<void>
using	meta::_args_a = vararg<_a>
using	meta::_args_b = vararg<_b>
using	meta::_args_c = vararg<_c>
template<META_TYPE_CONSTRAINT(list_like) ListOfLists>
using	meta::cartesian_product
	Given a list of lists ListOfLists, return a new list of lists that is the Cartesian Product.
template<typename ListOfLists>
using	meta::lazy::cartesian_product = defer<cartesian_product, ListOfLists>

Functions
template<typename T>
constexpr T *	meta::detail::_nullptr_v ()
	Returns a T nullptr.
constexpr std::size_t	meta::detail::count_i_ (bool const *const begin, bool const *const end, std::size_t n)
template<char... Chs>
constexpr fold< list< char_< Chs >... >, meta::size_t< 0 >, quote< detail::atoi_ > >	meta::operator""_z ()
	A user-defined literal that generates objects of type meta::size_t.

Variables
constexpr auto &&	meta::for_each = detail::static_const<detail::for_each_fn>::value
	for_each(List, UnaryFunction) calls the UnaryFunction for each argument in the List.

Detailed Description

Tiny meta-programming library.