|
using | meta::_args = vararg<void> |
|
using | meta::_args_a = vararg<_a> |
|
using | meta::_args_b = vararg<_b> |
|
using | meta::_args_c = vararg<_c> |
|
template<trait T> |
using | meta::_t = typename T::type |
| Type alias for T::type .
|
|
template<typename T > |
using | meta::lazy::_t = defer<_t, T> |
|
template<list_like L, typename State , invocable Fn> |
using | meta::accumulate = fold<L, State, Fn> |
| An alias for meta::fold .
|
|
template<typename L , typename State , typename Fn > |
using | meta::lazy::accumulate = defer<accumulate, L, State, Fn> |
|
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::alignof_ = defer<alignof_, T> |
|
template<list_like L, 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<typename... Bs> |
using | meta::and_ = _t<detail::_and_<Bs...>> |
| Logically AND together all the integral constant-wrapped Boolean parameters, with short-circuiting.
|
|
template<typename... Bs> |
using | meta::lazy::and_ = defer<and_, Bs...> |
|
template<list_like L, 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<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<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<list_like L, 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<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<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<typename Fn , typename... Ts> |
using | meta::lazy::bind_back = defer<bind_back, Fn, Ts...> |
|
template<typename Fn , typename... Ts> |
using | meta::lazy::bind_front = defer<bind_front, Fn, Ts...> |
|
template<integral T, 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<typename T , typename U > |
using | meta::lazy::bit_and = defer<bit_and, T, U> |
|
template<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::bit_not = defer<bit_not, T> |
|
template<integral T, 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<typename T , typename U > |
using | meta::lazy::bit_or = defer<bit_or, T, U> |
|
template<integral T, 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<typename T , typename U > |
using | meta::lazy::bit_xor = defer<bit_xor, T, U> |
|
template<bool B> |
using | meta::bool_ = std::integral_constant<bool, B> |
| An integral constant wrapper for bool .
|
|
template<list_like ListOfLists> |
using | meta::cartesian_product |
| Given a list of lists ListOfLists , return a new list of lists that is the Cartesian Product. Like the sequence function from the Haskell Prelude.
|
|
template<typename ListOfLists > |
using | meta::lazy::cartesian_product = defer<cartesian_product, ListOfLists> |
|
template<char Ch> |
using | meta::char_ = std::integral_constant<char, Ch> |
| An integral constant wrapper for char .
|
|
template<typename... Fns> |
using | meta::compose = compose_<Fns...> |
|
template<typename... Fns> |
using | meta::lazy::compose = defer<compose, Fns...> |
|
template<typename... Lists> |
using | meta::concat = concat_<Lists...> |
|
template<typename... Lists> |
using | meta::lazy::concat = defer<concat, Lists...> |
|
template<list_like ... Ls> |
using | meta::concat_ = _t<detail::concat_<Ls...>> |
| Concatenates several lists into a single list.
|
|
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<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<list_like L, 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<invocable Fn, 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<typename Fn , typename Q = quote<list>> |
using | meta::lazy::curry = defer<curry, Fn, Q> |
|
template<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<typename T > |
using | meta::lazy::dec = defer<dec, T> |
|
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<integral T, 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<typename T , typename U > |
using | meta::lazy::divides = defer<divides, T, U> |
|
template<list_like L, 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<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<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<integral T, 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<typename T , typename U > |
using | meta::lazy::equal_to = defer<equal_to, T, U> |
|
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. That is, those elements that don't satisfy the Pred are "removed".
|
|
template<typename L , typename Fn > |
using | meta::lazy::filter = defer<filter, L, Fn> |
|
template<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<list_like L, 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<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 . Returns #meta::npos if the type T was not found.
|
|
template<typename L , typename T > |
using | meta::lazy::find_index = defer<find_index, L, T> |
|
template<typename Pair > |
using | meta::first = front<Pair> |
| Retrieve the first element of the pair Pair .
|
|
template<typename Pair > |
using | meta::lazy::first = defer<first, Pair> |
|
template<typename Fn > |
using | meta::lazy::flip = defer<flip, Fn> |
|
template<list_like L, typename State , invocable Fn> |
using | meta::fold = _t<detail::fold_<L, 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 . That is, the State(N) for the list element A(N) is computed by Fn(State(N-1), A(N)) -> State(N) .
|
|
template<typename L , typename State , typename Fn > |
using | meta::lazy::fold = defer<fold, L, State, Fn> |
|
template<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<integral T, 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<typename T , typename U > |
using | meta::lazy::greater = defer<greater, T, U> |
|
template<integral T, 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<typename T , typename U > |
using | meta::lazy::greater_equal = defer<greater_equal, T, U> |
|
template<typename T > |
using | meta::lazy::id = defer<id, T> |
|
template<typename T > |
using | meta::id_t = _t<id<T>> |
| An alias for type T . Useful in non-deduced contexts.
|
|
template<typename... Args> |
using | meta::if_ = _t<detail::_if_<Args...>> |
| Select one type or another depending on a compile-time Boolean.
|
|
template<typename... Args> |
using | meta::lazy::if_ = defer<if_, Args...> |
|
template<bool If, typename... Args> |
using | meta::if_c = _t<detail::_if_<bool_<If>, Args...>> |
| Select one type or another depending on a compile-time Boolean.
|
|
template<bool If, typename... Args> |
using | meta::lazy::if_c = if_<bool_<If>, Args...> |
|
template<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<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<typename T > |
using | meta::lazy::inc = defer<inc, 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<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<int I> |
using | meta::int_ = std::integral_constant<int, I> |
| An integral constant wrapper for int .
|
|
template<typename T , T From, T To> |
using | meta::integer_range |
| Makes the integer sequence [From, To) .
|
|
template<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 , template< typename... > class C> |
using | meta::is = _t<detail::is_<T, C>> |
| is
|
|
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::is_trait = _t<detail::is_trait_<T>> |
|
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<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... Ts> |
using | meta::lambda = detail::lambda_<list<Ts...>> |
| For creating anonymous Invocables.
|
|
template<typename T , typename U > |
using | meta::lazy::less = defer<less, T, U> |
|
template<integral T, 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<typename T , typename U > |
using | meta::lazy::less_equal = defer<less_equal, T, U> |
|
template<integral T, 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<typename... As> |
using | meta::lazy::let = defer<let, As...> |
|
template<typename... As> |
using | meta::let = _t<_t<detail::let_<As...>>> |
| A lexically scoped expression with local variables.
|
|
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... Ts> |
using | meta::lazy::max = defer<max, Ts...> |
|
template<typename... Ts> |
using | meta::max = max_<Ts...> |
|
template<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::lazy::min = defer<min, Ts...> |
|
template<typename... Ts> |
using | meta::min = min_<Ts...> |
|
template<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 T , typename U > |
using | meta::lazy::minus = defer<minus, T, U> |
|
template<integral T, 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<typename T , typename U > |
using | meta::lazy::modulus = defer<modulus, T, U> |
|
template<integral T, 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<typename T , typename U > |
using | meta::lazy::multiplies = defer<multiplies, T, U> |
|
template<integral T, 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<typename T > |
using | meta::lazy::negate = defer<negate, T> |
|
template<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<typename L , invocable Fn> |
using | meta::lazy::none_of = defer<none_of, L, Fn> |
|
template<list_like L, 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 B > |
using | meta::lazy::not_ = defer<not_, B> |
|
template<integral B> |
using | meta::not_ = not_c<B::type::value> |
| Logically negate the integral constant-wrapped Boolean parameter.
|
|
template<bool B> |
using | meta::not_c = bool_<!B> |
| Logically negate the Boolean parameter.
|
|
template<typename T , typename U > |
using | meta::lazy::not_equal_to = defer<not_equal_to, T, U> |
|
template<integral T, 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<typename Fn > |
using | meta::lazy::not_fn = defer<not_fn, Fn> |
|
template<invocable Fn> |
using | meta::not_fn = compose<quote<not_>, Fn> |
| Logically negate the result of invocable Fn .
|
|
using | meta::npos = meta::size_t<std::size_t(-1)> |
| A special value used to indicate no matches. It equals the maximum value representable by std::size_t.
|
|
template<typename Fn , typename G > |
using | meta::lazy::on = defer<on, Fn, G> |
|
template<typename... Fns> |
using | meta::on = on_<Fns...> |
|
template<invocable ... Fns> |
using | meta::on_ = detail::on_<Fns...> |
| Use as on<Fn, Gs...> . Creates an invocable that applies invocable Fn to the result of applying invocable compose<Gs...> to all the arguments.
|
|
template<typename... Bs> |
using | meta::lazy::or_ = defer<or_, Bs...> |
|
template<typename... Bs> |
using | meta::or_ = _t<detail::_or_<Bs...>> |
| Logically OR together all the integral constant-wrapped Boolean parameters, with short-circuiting.
|
|
template<typename F , typename S > |
using | meta::pair = list<F, S> |
| A list with exactly two elements.
|
|
template<typename L , typename Fn > |
using | meta::lazy::partition = defer<partition, L, Fn> |
|
template<list_like L, 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 T , typename U > |
using | meta::lazy::plus = defer<plus, T, U> |
|
template<integral T, 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<typename L > |
using | meta::lazy::pop_front = defer<pop_front, L> |
|
template<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 T > |
using | meta::protect = detail::protect_<T> |
| For preventing the evaluation of a nested defer ed computation in a let or lambda expression.
|
|
template<typename... Ts> |
using | meta::lazy::push_back = defer<push_back, Ts...> |
|
template<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_front = defer<push_front, Ts...> |
|
template<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<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 N , typename T = void> |
using | meta::lazy::repeat_n = defer<repeat_n, N, T> |
|
template<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<std::size_t N, typename T = void> |
using | meta::lazy::repeat_n_c = defer<repeat_n, meta::size_t<N>, T> |
|
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<typename L , typename T , typename U > |
using | meta::lazy::replace = defer<replace, T, U> |
|
template<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 C , typename U > |
using | meta::lazy::replace_if = defer<replace_if, C, U> |
|
template<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 > |
using | meta::lazy::reverse = defer<reverse, L> |
|
template<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 , typename T > |
using | meta::lazy::reverse_find = defer<reverse_find, L, T> |
|
template<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 Fn > |
using | meta::lazy::reverse_find_if = defer<reverse_find_if, L, Fn> |
|
template<list_like L, 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 T > |
using | meta::lazy::reverse_find_index = defer<reverse_find_index, L, T> |
|
template<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 . Returns #meta::npos if the type T was not found.
|
|
template<typename L , typename State , typename Fn > |
using | meta::lazy::reverse_fold = defer<reverse_fold, L, State, Fn> |
|
template<list_like L, typename State , 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 . That is, the State(N) for the list element A(N) is computed by Fn(A(N), State(N+1)) -> State(N) .
|
|
template<typename Pair > |
using | meta::lazy::second = defer<second, Pair> |
|
template<typename Pair > |
using | meta::second = front<pop_front<Pair>> |
| Retrieve the first element of the pair Pair .
|
|
template<typename L > |
using | meta::lazy::size = defer<size, L> |
|
template<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<std::size_t N> |
using | meta::size_t = std::integral_constant<std::size_t, N> |
| An integral constant wrapper for std::size_t .
|
|
template<typename T > |
using | meta::lazy::sizeof_ = defer<sizeof_, T> |
|
template<typename T > |
using | meta::sizeof_ = meta::size_t<sizeof(T)> |
| An alias that computes the size of the type T .
|
|
template<typename L , typename Fn > |
using | meta::lazy::sort = defer<sort, L, Fn> |
|
template<list_like L, 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... Bs> |
using | meta::lazy::strict_and = defer<strict_and, Bs...> |
|
template<typename... Bs> |
using | meta::strict_and = strict_and_<Bs...> |
|
template<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::lazy::strict_or = defer<strict_or, Bs...> |
|
template<typename... Bs> |
using | meta::strict_or = strict_or_<Bs...> |
|
template<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... Args> |
using | meta::lazy::transform = defer<transform, Args...> |
|
template<typename... Args> |
using | meta::transform = _t<detail::transform_<Args...>> |
| Return a new meta::list constructed by transforming all the elements in L with the unary invocable Fn . transform can also be called with two lists of the same length and a binary invocable, in which case it returns a new list constructed with the results of calling Fn with each element in the lists, pairwise.
|
|
template<typename ListOfLists > |
using | meta::lazy::transpose = defer<transpose, ListOfLists> |
|
template<list_like ListOfLists> |
using | meta::transpose |
| Given a list of lists of types ListOfLists , transpose the elements from the lists.
|
|
template<typename Fn > |
using | meta::lazy::uncurry = defer<uncurry, Fn> |
|
template<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 L > |
using | meta::lazy::unique = defer<unique, L> |
|
template<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 T > |
using | meta::vararg = detail::vararg_<T> |
| For defining variadic placeholders.
|
|
template<typename... > |
using | meta::void_ = void |
| An alias for void .
|
|
template<typename ListOfLists > |
using | meta::lazy::zip = defer<zip, ListOfLists> |
|
template<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::list s.
|
|
template<typename Fn , typename ListOfLists > |
using | meta::lazy::zip_with = defer<zip_with, Fn, ListOfLists> |
|
template<invocable Fn, 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.
|
|