|  | 
| 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.  More...
 | 
|  | 
| 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.  More...
 | 
|  | 
| 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 trueifinvoke<Fn, A>::valueistruefor all elementsAinmeta::listL;false, otherwise.  More...
 | 
|  | 
| 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 trueifinvoke<Fn, A>::valueistruefor any elementAinmeta::listL;false, otherwise.  More...
 | 
|  | 
| 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 Fnusing the types in the type listLas 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::listin a way determined bymeta::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 Nth element in themeta::listL.  More...
 | 
|  | 
| 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 Nth element in themeta::listL.  More...
 | 
|  | 
| template<list_like L> | 
| using | meta::back = _t< detail::back_< L > > | 
|  | Return the last element in meta::listL.  More...
 | 
|  | 
| 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 = std::integral_constant< decltype(T::type::value &U::type::value), T::type::value &U::type::value > | 
|  | An integral constant wrapper around the result of bitwise-and'ing the two wrapped integers T::type::valueandU::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 = std::integral_constant< decltype(T::type::value|U::type::value), T::type::value|U::type::value > | 
|  | An integral constant wrapper around the result of bitwise-or'ing the two wrapped integers T::type::valueandU::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 = std::integral_constant< decltype(T::type::value ^ U::type::value), T::type::value ^ U::type::value > | 
|  | An integral constant wrapper around the result of bitwise-exclusive-or'ing the two wrapped integers T::type::valueandU::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 = reverse_fold< ListOfLists, list< list<> >, quote_trait< detail::cartesian_product_fn > > | 
|  | Given a list of lists ListOfLists, return a new list of lists that is the Cartesian Product. Like thesequencefunction from the Haskell Prelude.  More...
 | 
|  | 
| 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.  More... 
 | 
|  | 
| 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 Tappears in the listL.  More...
 | 
|  | 
| 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 Fnevaluates to true for all the elements in the listL.  More...
 | 
|  | 
| 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 Fnwith the type listQ.
 | 
|  | 
| 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 Cwith type parametersTsin alambdaorletexpression.  More...
 | 
|  | 
| 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 Cwith integral constant parametersIsin alambdaorletexpression.  More...
 | 
|  | 
| template<integral T, integral U> | 
| using | meta::divides = std::integral_constant< decltype(T::type::value/U::type::value), T::type::value/U::type::value > | 
|  | An integral constant wrapper around the result of dividing the two wrapped integers T::type::valueandU::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::listby removing the firstNelements fromL.  More...
 | 
|  | 
| 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::listby removing the firstNelements fromL.  More...
 | 
|  | 
| template<list_like L> | 
| using | meta::empty = bool_< 0==size< L >::type::value > | 
|  | An Boolean integral constant wrapper around trueifLis an empty type list;false, otherwise.  More...
 | 
|  | 
| 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::valueandU::type::valuefor 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 Lthat satisfy the CallablePredsuch thatinvoke<Pred,A>::valueistrueare present. That is, those elements that don't satisfy thePredare "removed".  More...
 | 
|  | 
| 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 Lstarting at the first occurrence ofT, if any such element exists; the empty list, otherwise.  More...
 | 
|  | 
| 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 Lstarting at the first elementAsuch thatinvoke<Fn, A>::valueistrue, if any such element exists; the empty list, otherwise.  More...
 | 
|  | 
| 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 Twithin the listL. Returns#meta::nposif the typeTwas not found.  More...
 | 
|  | 
| 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 pairPair.
 | 
|  | 
| 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::listconstructed by doing a left fold of the listLusing binary invocableFnand initial stateState. That is, theState(N)for the list elementA(N)is computed byFn(State(N-1), A(N)) -> State(N).  More...
 | 
|  | 
| 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::listL.  More...
 | 
|  | 
| 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 trueifT::type::valueis greater thanU::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 trueifT::type::valueis greater than or equal toU::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 trueif there is at least one occurrence ofTinL.  More...
 | 
|  | 
| 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.  More... 
 | 
|  | 
| 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 = _t< detail::coerce_indices_< T, From, make_index_sequence< detail::range_distance_(From, To)> > > | 
|  | Makes the integer sequence [From, To).  More...
 | 
|  | 
| template<invocable Fn, typename... Args> | 
| using | meta::invoke = typename Fn::template invoke< Args... > | 
|  | Evaluate the invocable Fnwith the argumentsArgs.
 | 
|  | 
| 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  More... 
 | 
|  | 
| template<typename T > | 
| using | meta::is_callable = _t< detail::is_callable_< T > > | 
|  | An alias for std::true_typeifT::invokeexists and names a class template or alias template; otherwise, it's an alias forstd::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 letor alambda.
 | 
|  | 
| template<list_like ListOfLists> | 
| using | meta::join = apply< quote< concat >, ListOfLists > | 
|  | Joins a list of lists into a single list.  More... 
 | 
|  | 
| template<typename ListOfLists > | 
| using | meta::lazy::join = defer< join, ListOfLists > | 
|  | 
| template<typename... Ts> | 
| using | meta::lambda = detail::lambda_< list< Ts... > > | 
|  | For creating anonymous Invocables.  More... 
 | 
|  | 
| template<integral T, integral U> | 
| using | meta::less = bool_<(T::type::value< U::type::value)> | 
|  | A Boolean integral constant wrapper around trueifT::type::valueis less thanU::type::value;false, otherwise.
 | 
|  | 
| template<typename T , typename U > | 
| using | meta::lazy::less = defer< less, T, U > | 
|  | 
| template<integral T, integral U> | 
| using | meta::less_equal = bool_<(T::type::value<=U::type::value)> | 
|  | A Boolean integral constant wrapper around trueifT::type::valueis less than or equal toU::type::value;false, otherwise.
 | 
|  | 
| template<typename T , typename U > | 
| using | meta::lazy::less_equal = defer< less_equal, T, U > | 
|  | 
| template<typename... As> | 
| using | meta::let = _t< _t< detail::let_< As... > > > | 
|  | A lexically scoped expression with local variables.  More... 
 | 
|  | 
| template<typename... As> | 
| using | meta::lazy::let = defer< let, As... > | 
|  | 
| template<std::size_t N> | 
| using | meta::make_index_sequence = _t< detail::make_indices_< N, index_sequence< 0 >, detail::strategy_(1, N)> > | 
|  | Generate index_sequencecontaining integer constants [0,1,2,...,N-1].  More...
 | 
|  | 
| template<typename T , T N> | 
| using | meta::make_integer_sequence = _t< detail::coerce_indices_< T, 0, make_index_sequence< static_cast< std::size_t >(N)> > > | 
|  | Generate integer_sequencecontaining integer constants [0,1,2,...,N-1].  More...
 | 
|  | 
| template<typename... Ts> | 
| using | meta::max = max_< Ts... > | 
|  | 
| template<typename... Ts> | 
| using | meta::lazy::max = defer< 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::min = min_< Ts... > | 
|  | 
| template<typename... Ts> | 
| using | meta::lazy::min = defer< 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<integral T, integral U> | 
| using | meta::minus = std::integral_constant< decltype(T::type::value - U::type::value), T::type::value - U::type::value > | 
|  | An integral constant wrapper around the result of subtracting the two wrapped integers T::type::valueandU::type::value.
 | 
|  | 
| template<typename T , typename U > | 
| using | meta::lazy::minus = defer< minus, T, U > | 
|  | 
| template<integral T, integral U> | 
| using | meta::modulus = std::integral_constant< decltype(T::type::value % U::type::value), T::type::value % U::type::value > | 
|  | An integral constant wrapper around the remainder of dividing the two wrapped integers T::type::valueandU::type::value.
 | 
|  | 
| template<typename T , typename U > | 
| using | meta::lazy::modulus = defer< modulus, T, U > | 
|  | 
| template<integral T, integral U> | 
| using | meta::multiplies = std::integral_constant< decltype(T::type::value *U::type::value), T::type::value *U::type::value > | 
|  | An integral constant wrapper around the result of multiplying the two wrapped integers T::type::valueandU::type::value.
 | 
|  | 
| template<typename T , typename U > | 
| using | meta::lazy::multiplies = defer< multiplies, T, U > | 
|  | 
| 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 T > | 
| using | meta::lazy::negate = defer< negate, T > | 
|  | 
| template<list_like L, invocable Fn> | 
| using | meta::none_of = empty< find_if< L, Fn > > | 
|  | A Boolean integral constant wrapper around trueifinvoke<Fn, A>::valueisfalsefor all elementsAinmeta::listL;false, otherwise.  More...
 | 
|  | 
| template<typename L , invocable Fn> | 
| using | meta::lazy::none_of = defer< none_of, L, Fn > | 
|  | 
| template<integral B> | 
| using | meta::not_ = not_c< B::type::value > | 
|  | Logically negate the integral constant-wrapped Boolean parameter. 
 | 
|  | 
| template<typename B > | 
| using | meta::lazy::not_ = defer< not_, B > | 
|  | 
| template<bool B> | 
| using | meta::not_c = bool_<!B > | 
|  | Logically negate the Boolean parameter. 
 | 
|  | 
| 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::valueandU::type::valuefor inequality.
 | 
|  | 
| template<typename T , typename U > | 
| using | meta::lazy::not_equal_to = defer< not_equal_to, T, U > | 
|  | 
| template<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 > | 
|  | 
| 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... Fns> | 
| using | meta::on = on_< Fns... > | 
|  | 
| template<typename Fn , typename G > | 
| using | meta::lazy::on = defer< on, Fn, G > | 
|  | 
| template<invocable ... Fns> | 
| using | meta::on_ = detail::on_< Fns... > | 
|  | Use as on<Fn, Gs...>. Creates an invocable that applies invocableFnto the result of applying invocablecompose<Gs...>to all the arguments.
 | 
|  | 
| 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... Bs> | 
| using | meta::lazy::or_ = defer< or_, Bs... > | 
|  | 
| template<typename F , typename S > | 
| using | meta::pair = list< F, S > | 
|  | A list with exactly two elements. 
 | 
|  | 
| 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 Lthat satisfy the invocableFnsuch thatinvoke<Fn,A>::valueistrueare present in the first list and the rest are in the second.  More...
 | 
|  | 
| template<typename L , typename Fn > | 
| using | meta::lazy::partition = defer< partition, L, Fn > | 
|  | 
| template<integral T, integral U> | 
| using | meta::plus = std::integral_constant< decltype(T::type::value+U::type::value), T::type::value+U::type::value > | 
|  | An integral constant wrapper around the result of adding the two wrapped integers T::type::valueandU::type::value.
 | 
|  | 
| template<typename T , typename U > | 
| using | meta::lazy::plus = defer< plus, T, U > | 
|  | 
| template<list_like L> | 
| using | meta::pop_front = _t< detail::pop_front_< L > > | 
|  | Return a new meta::listby removing the first element from the front ofL.  More...
 | 
|  | 
| template<typename L > | 
| using | meta::lazy::pop_front = defer< pop_front, L > | 
|  | 
| template<typename T > | 
| using | meta::protect = detail::protect_< T > | 
|  | For preventing the evaluation of a nested defered computation in aletorlambdaexpression.
 | 
|  | 
| template<list_like L, typename... Ts> | 
| using | meta::push_back = apply< bind_back< quote< list >, Ts... >, L > | 
|  | Return a new meta::listby adding the elementTto the back ofL.  More...
 | 
|  | 
| template<typename... Ts> | 
| using | meta::lazy::push_back = defer< push_back, Ts... > | 
|  | 
| template<list_like L, typename... Ts> | 
| using | meta::push_front = apply< bind_front< quote< list >, Ts... >, L > | 
|  | Return a new meta::listby adding the elementTto the front ofL.  More...
 | 
|  | 
| template<typename... Ts> | 
| using | meta::lazy::push_front = defer< push_front, Ts... > | 
|  | 
| template<template< typename... > class C> | 
| using | meta::quote_trait = compose< quote< _t >, quote< C > > | 
|  | Turn a trait template Cinto an invocable.  More...
 | 
|  | 
| template<typename T , template< T... > class C> | 
| using | meta::quote_trait_i = compose< quote< _t >, quote_i< T, C > > | 
|  | Turn a trait template Ctaking literals of typeTinto an invocable.
 | 
|  | 
| template<integral N, typename T  = void> | 
| using | meta::repeat_n = repeat_n_c< N::type::value, T > | 
|  | Generate list<T,T,T...T>of sizeNarguments.  More...
 | 
|  | 
| 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::repeat_n_c = _t< detail::repeat_n_c_< T, make_index_sequence< N > > > | 
|  | Generate list<T,T,T...T>of sizeNarguments.  More...
 | 
|  | 
| template<std::size_t N, typename T  = void> | 
| using | meta::lazy::repeat_n_c = defer< repeat_n, meta::size_t< N >, T > | 
|  | 
| template<list_like L, typename T , typename U > | 
| using | meta::replace = _t< detail::replace_< L, T, U > > | 
|  | Return a new meta::listwhere all instances of typeThave been replaced withU.  More...
 | 
|  | 
| template<typename L , typename T , typename U > | 
| using | meta::lazy::replace = defer< replace, T, U > | 
|  | 
| template<list_like L, typename C , typename U > | 
| using | meta::replace_if = _t< detail::replace_if_< L, C, U > > | 
|  | Return a new meta::listwhere all elementsAof the listLfor whichinvoke<C,A>::valueistruehave been replaced withU.  More...
 | 
|  | 
| template<typename L , typename C , typename U > | 
| using | meta::lazy::replace_if = defer< replace_if, C, U > | 
|  | 
| template<list_like L> | 
| using | meta::reverse = _t< detail::reverse_< L > > | 
|  | Return a new meta::listby reversing the elements in the listL.  More...
 | 
|  | 
| template<typename L > | 
| using | meta::lazy::reverse = defer< reverse, L > | 
|  | 
| 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 Lstarting at the last occurrence ofT, if any such element exists; the empty list, otherwise.  More...
 | 
|  | 
| template<typename L , typename T > | 
| using | meta::lazy::reverse_find = defer< reverse_find, L, T > | 
|  | 
| template<list_like L, invocable Fn> | 
| using | meta::reverse_find_if = _t< detail::reverse_find_if_< L, Fn > > | 
|  | Return the tail of the list Lstarting at the last elementAsuch thatinvoke<Fn, A>::valueistrue, if any such element exists; the empty list, otherwise.  More...
 | 
|  | 
| template<typename L , typename Fn > | 
| using | meta::lazy::reverse_find_if = defer< reverse_find_if, L, Fn > | 
|  | 
| 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 Twithin the listL. Returns#meta::nposif the typeTwas not found.  More...
 | 
|  | 
| template<typename L , typename T > | 
| using | meta::lazy::reverse_find_index = defer< reverse_find_index, L, T > | 
|  | 
| template<list_like L, typename State , invocable Fn> | 
| using | meta::reverse_fold = _t< detail::reverse_fold_< L, State, Fn > > | 
|  | Return a new meta::listconstructed by doing a right fold of the listLusing binary invocableFnand initial stateState. That is, theState(N)for the list elementA(N)is computed byFn(A(N), State(N+1)) -> State(N).  More...
 | 
|  | 
| template<typename L , typename State , typename Fn > | 
| using | meta::lazy::reverse_fold = defer< reverse_fold, L, State, Fn > | 
|  | 
| template<typename Pair > | 
| using | meta::second = front< pop_front< Pair > > | 
|  | Retrieve the first element of the pairPair.
 | 
|  | 
| template<typename Pair > | 
| using | meta::lazy::second = defer< second, Pair > | 
|  | 
| template<list_like L> | 
| using | meta::size = meta::size_t< L::size()> | 
|  | An integral constant wrapper that is the size of the meta::listL.
 | 
|  | 
| template<typename L > | 
| using | meta::lazy::size = defer< size, 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::sizeof_ = meta::size_t< sizeof(T)> | 
|  | An alias that computes the size of the type T.  More...
 | 
|  | 
| template<typename T > | 
| using | meta::lazy::sizeof_ = defer< sizeof_, T > | 
|  | 
| template<list_like L, invocable Fn> | 
| using | meta::sort = _t< detail::sort_< L, Fn > > | 
|  | Return a new meta::listthat is sorted according to invocable predicateFn.  More...
 | 
|  | 
| template<typename L , typename Fn > | 
| using | meta::lazy::sort = defer< sort, L, Fn > | 
|  | 
| template<typename... Bs> | 
| using | meta::strict_and = strict_and_< Bs... > | 
|  | 
| template<typename... Bs> | 
| using | meta::lazy::strict_and = defer< 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::strict_or = strict_or_< Bs... > | 
|  | 
| template<typename... Bs> | 
| using | meta::lazy::strict_or = defer< 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::transform = _t< detail::transform_< Args... > > | 
|  | Return a new meta::listconstructed by transforming all the elements inLwith the unary invocableFn.transformcan 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 callingFnwith each element in the lists, pairwise.  More...
 | 
|  | 
| template<typename... Args> | 
| using | meta::lazy::transform = defer< transform, Args... > | 
|  | 
| template<list_like ListOfLists> | 
| using | meta::transpose = fold< ListOfLists, repeat_n< size< front< ListOfLists > >, list<> >, bind_back< quote< transform >, quote< push_back > > > | 
|  | Given a list of lists of types ListOfLists, transpose the elements from the lists.  More...
 | 
|  | 
| template<typename ListOfLists > | 
| using | meta::lazy::transpose = defer< transpose, ListOfLists > | 
|  | 
| 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 Fnwith the types.
 | 
|  | 
| template<typename Fn > | 
| using | meta::lazy::uncurry = defer< uncurry, Fn > | 
|  | 
| template<list_like L> | 
| using | meta::unique = fold< L, list<>, quote_trait< detail::insert_back_ > > | 
|  | Return a new meta::listwhere all duplicate elements have been removed.  More...
 | 
|  | 
| template<typename L > | 
| using | meta::lazy::unique = defer< unique, L > | 
|  | 
| template<typename T > | 
| using | meta::vararg = detail::vararg_< T > | 
|  | For defining variadic placeholders. 
 | 
|  | 
| template<typename... > | 
| using | meta::void_ = void | 
|  | An alias for void.
 | 
|  | 
| 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 intometa::lists.  More...
 | 
|  | 
| template<typename ListOfLists > | 
| using | meta::lazy::zip = defer< zip, ListOfLists > | 
|  | 
| template<invocable Fn, list_like ListOfLists> | 
| using | meta::zip_with = transform< transpose< ListOfLists >, uncurry< Fn > > | 
|  | Given a list of lists of types ListOfListsand an invocableFn, construct a new list by callingFnwith the elements from the lists pairwise.  More...
 | 
|  | 
| template<typename Fn , typename ListOfLists > | 
| using | meta::lazy::zip_with = defer< zip_with, Fn, ListOfLists > | 
|  |