|  | 
| using | _args = vararg< void > | 
|  | 
| using | _args_a = vararg< _a > | 
|  | 
| using | _args_b = vararg< _b > | 
|  | 
| using | _args_c = vararg< _c > | 
|  | 
| template<trait T> | 
| using | _t = typename T::type | 
|  | Type alias for T::type.
 | 
|  | 
| template<list_like L, typename State , invocable Fn> | 
| using | accumulate = fold< L, State, Fn > | 
|  | An alias for meta::fold.  More...
 | 
|  | 
| template<typename T > | 
| using | alignof_ = meta::size_t< alignof(T)> | 
|  | An alias that computes the alignment required for any instance of the type T.  More...
 | 
|  | 
| template<list_like L, invocable Fn> | 
| using | 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... Bs> | 
| using | and_ = _t< detail::_and_< Bs... > > | 
|  | Logically AND together all the integral constant-wrapped Boolean parameters, with short-circuiting. 
 | 
|  | 
| template<list_like L, invocable Fn> | 
| using | 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<invocable Fn, typename L > | 
| using | apply = _t< extension::apply< Fn, L > > | 
|  | Applies the invocable Fnusing the types in the type listLas arguments.
 | 
|  | 
| template<typename Sequence > | 
| using | 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<list_like L, integral N> | 
| using | at = at_c< L, N::type::value > | 
|  | Return the Nth element in themeta::listL.  More...
 | 
|  | 
| template<list_like L, std::size_t N> | 
| using | at_c = _t< detail::at_< L, N > > | 
|  | Return the Nth element in themeta::listL.  More...
 | 
|  | 
| template<list_like L> | 
| using | back = _t< detail::back_< L > > | 
|  | Return the last element in meta::listL.  More...
 | 
|  | 
| template<integral T, integral U> | 
| using | 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<integral T> | 
| using | 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<integral T, integral U> | 
| using | 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<integral T, integral U> | 
| using | 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<bool B> | 
| using | bool_ = std::integral_constant< bool, B > | 
|  | An integral constant wrapper for bool.
 | 
|  | 
| template<list_like ListOfLists> | 
| using | 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<char Ch> | 
| using | char_ = std::integral_constant< char, Ch > | 
|  | An integral constant wrapper for char.
 | 
|  | 
| template<typename... Fns> | 
| using | compose = compose_< Fns... > | 
|  | 
| template<typename... Lists> | 
| using | concat = concat_< Lists... > | 
|  | 
| template<list_like ... Ls> | 
| using | concat_ = _t< detail::concat_< Ls... > > | 
|  | Concatenates several lists into a single list.  More... 
 | 
|  | 
| template<bool If, typename Then , typename Else  = void> | 
| using | 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 | count = _t< detail::count_< L, T > > | 
|  | Count the number of times a type Tappears in the listL.  More...
 | 
|  | 
| template<list_like L, invocable Fn> | 
| using | 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<invocable Fn, invocable Q = quote<list>> | 
| using | 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<integral T> | 
| using | 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<template< typename... > class C, typename... Ts> | 
| using | 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 | 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 | 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<list_like L, integral N> | 
| using | drop = drop_c< L, N::type::value > | 
|  | Return a new meta::listby removing the firstNelements fromL.  More...
 | 
|  | 
| template<list_like L, std::size_t N> | 
| using | drop_c = _t< detail::drop_< L, N > > | 
|  | Return a new meta::listby removing the firstNelements fromL.  More...
 | 
|  | 
| template<list_like L> | 
| using | empty = bool_< 0==size< L >::type::value > | 
|  | An Boolean integral constant wrapper around trueifLis an empty type list;false, otherwise.  More...
 | 
|  | 
| template<integral T, integral U> | 
| using | 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 L , typename Pred > | 
| using | 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<list_like L, typename T > | 
| using | 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<list_like L, invocable Fn> | 
| using | 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<list_like L, typename T > | 
| using | 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 Pair > | 
| using | first = front< Pair > | 
|  | Retrieve the first element of the pairPair.
 | 
|  | 
| template<list_like L, typename State , invocable Fn> | 
| using | 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<list_like L> | 
| using | front = _t< detail::front_< L > > | 
|  | Return the first element in meta::listL.  More...
 | 
|  | 
| template<integral T, integral U> | 
| using | greater = bool_<(T::type::value > U::type::value)> | 
|  | A Boolean integral constant wrapper around trueifT::type::valueis greater thanU::type::value;false, otherwise.
 | 
|  | 
| template<integral T, integral U> | 
| using | 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 > | 
| using | id_t = _t< id< T > > | 
|  | An alias for type T. Useful in non-deduced contexts.
 | 
|  | 
| template<typename... Args> | 
| using | if_ = _t< detail::_if_< Args... > > | 
|  | Select one type or another depending on a compile-time Boolean. 
 | 
|  | 
| template<bool If, typename... Args> | 
| using | if_c = _t< detail::_if_< bool_< If >, Args... > > | 
|  | Select one type or another depending on a compile-time Boolean. 
 | 
|  | 
| template<list_like L, typename T > | 
| using | in = not_< empty< find< L, T > > > | 
|  | A Boolean integral constant wrapper around trueif there is at least one occurrence ofTinL.  More...
 | 
|  | 
| template<integral T> | 
| using | 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<std::size_t... Is> | 
| using | 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 | inherit = meta::_t< detail::inherit_< L > > | 
|  | A type that inherits from all the types in the list.  More... 
 | 
|  | 
| template<int I> | 
| using | int_ = std::integral_constant< int, I > | 
|  | An integral constant wrapper for int.
 | 
|  | 
| template<typename T , T From, T To> | 
| using | 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 | invoke = typename Fn::template invoke< Args... > | 
|  | Evaluate the invocable Fnwith the argumentsArgs.
 | 
|  | 
| template<typename T , template< typename... > class C> | 
| using | is = _t< detail::is_< T, C > > | 
|  | is  More... 
 | 
|  | 
| template<typename T > | 
| using | 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 | is_trait = _t< detail::is_trait_< T > > | 
|  | 
| template<typename T > | 
| using | is_valid = detail::is_valid_< T > | 
|  | For testing whether a deferred computation will succeed in a letor alambda.
 | 
|  | 
| template<list_like ListOfLists> | 
| using | join = apply< quote< concat >, ListOfLists > | 
|  | Joins a list of lists into a single list.  More... 
 | 
|  | 
| template<typename... Ts> | 
| using | lambda = detail::lambda_< list< Ts... > > | 
|  | For creating anonymous Invocables.  More... 
 | 
|  | 
| template<integral T, integral U> | 
| using | less = bool_<(T::type::value< U::type::value)> | 
|  | A Boolean integral constant wrapper around trueifT::type::valueis less thanU::type::value;false, otherwise.
 | 
|  | 
| template<integral T, integral U> | 
| using | 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... As> | 
| using | let = _t< _t< detail::let_< As... > > > | 
|  | A lexically scoped expression with local variables.  More... 
 | 
|  | 
| template<std::size_t N> | 
| using | 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 | 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 | max = max_< Ts... > | 
|  | 
| template<integral ... Ts> | 
| using | 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 | min = min_< Ts... > | 
|  | 
| template<integral ... Ts> | 
| using | 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 | 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<integral T, integral U> | 
| using | 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<integral T, integral U> | 
| using | 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<integral T> | 
| using | 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<list_like L, invocable Fn> | 
| using | none_of = empty< find_if< L, Fn > > | 
|  | A Boolean integral constant wrapper around trueifinvoke<Fn, A>::valueisfalsefor all elementsAinmeta::listL;false, otherwise.  More...
 | 
|  | 
| template<integral B> | 
| using | not_ = not_c< B::type::value > | 
|  | Logically negate the integral constant-wrapped Boolean parameter. 
 | 
|  | 
| template<bool B> | 
| using | not_c = bool_<!B > | 
|  | Logically negate the Boolean parameter. 
 | 
|  | 
| template<integral T, integral U> | 
| using | 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<invocable Fn> | 
| using | not_fn = compose< quote< not_ >, Fn > | 
|  | Logically negate the result of invocable Fn.
 | 
|  | 
| using | 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 | on = on_< Fns... > | 
|  | 
| template<invocable ... Fns> | 
| using | 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 | or_ = _t< detail::_or_< Bs... > > | 
|  | Logically OR together all the integral constant-wrapped Boolean parameters, with short-circuiting. 
 | 
|  | 
| template<typename F , typename S > | 
| using | pair = list< F, S > | 
|  | A list with exactly two elements. 
 | 
|  | 
| template<list_like L, invocable Fn> | 
| using | 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<integral T, integral U> | 
| using | 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<list_like L> | 
| using | pop_front = _t< detail::pop_front_< L > > | 
|  | Return a new meta::listby removing the first element from the front ofL.  More...
 | 
|  | 
| template<typename T > | 
| using | protect = detail::protect_< T > | 
|  | For preventing the evaluation of a nested defered computation in aletorlambdaexpression.
 | 
|  | 
| template<list_like L, typename... Ts> | 
| using | push_back = apply< bind_back< quote< list >, Ts... >, L > | 
|  | Return a new meta::listby adding the elementTto the back ofL.  More...
 | 
|  | 
| template<list_like L, typename... Ts> | 
| using | push_front = apply< bind_front< quote< list >, Ts... >, L > | 
|  | Return a new meta::listby adding the elementTto the front ofL.  More...
 | 
|  | 
| template<template< typename... > class C> | 
| using | quote_trait = compose< quote< _t >, quote< C > > | 
|  | Turn a trait template Cinto an invocable.  More...
 | 
|  | 
| template<typename T , template< T... > class C> | 
| using | 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 | repeat_n = repeat_n_c< N::type::value, T > | 
|  | Generate list<T,T,T...T>of sizeNarguments.  More...
 | 
|  | 
| template<std::size_t N, typename T  = void> | 
| using | repeat_n_c = _t< detail::repeat_n_c_< T, make_index_sequence< N > > > | 
|  | Generate list<T,T,T...T>of sizeNarguments.  More...
 | 
|  | 
| template<list_like L, typename T , typename U > | 
| using | replace = _t< detail::replace_< L, T, U > > | 
|  | Return a new meta::listwhere all instances of typeThave been replaced withU.  More...
 | 
|  | 
| template<list_like L, typename C , typename U > | 
| using | 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<list_like L> | 
| using | reverse = _t< detail::reverse_< L > > | 
|  | Return a new meta::listby reversing the elements in the listL.  More...
 | 
|  | 
| template<list_like L, typename T > | 
| using | 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<list_like L, invocable Fn> | 
| using | 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<list_like L, typename T > | 
| using | 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<list_like L, typename State , invocable Fn> | 
| using | 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 Pair > | 
| using | second = front< pop_front< Pair > > | 
|  | Retrieve the first element of the pairPair.
 | 
|  | 
| template<list_like L> | 
| using | size = meta::size_t< L::size()> | 
|  | An integral constant wrapper that is the size of the meta::listL.
 | 
|  | 
| template<std::size_t N> | 
| using | size_t = std::integral_constant< std::size_t, N > | 
|  | An integral constant wrapper for std::size_t.
 | 
|  | 
| template<typename T > | 
| using | sizeof_ = meta::size_t< sizeof(T)> | 
|  | An alias that computes the size of the type T.  More...
 | 
|  | 
| template<list_like L, invocable Fn> | 
| using | sort = _t< detail::sort_< L, Fn > > | 
|  | Return a new meta::listthat is sorted according to invocable predicateFn.  More...
 | 
|  | 
| template<typename... Bs> | 
| using | strict_and = strict_and_< Bs... > | 
|  | 
| template<integral ... Bs> | 
| using | strict_and_ = and_c< Bs::type::value... > | 
|  | Logically AND together all the integral constant-wrapped Boolean parameters, without short-circuiting. 
 | 
|  | 
| template<typename... Bs> | 
| using | strict_or = strict_or_< Bs... > | 
|  | 
| template<integral ... Bs> | 
| using | strict_or_ = or_c< Bs::type::value... > | 
|  | Logically OR together all the integral constant-wrapped Boolean parameters, without short-circuiting. 
 | 
|  | 
| template<typename... Args> | 
| using | 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<list_like ListOfLists> | 
| using | 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<invocable Fn> | 
| using | 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<list_like L> | 
| using | unique = fold< L, list<>, quote_trait< detail::insert_back_ > > | 
|  | Return a new meta::listwhere all duplicate elements have been removed.  More...
 | 
|  | 
| template<typename T > | 
| using | vararg = detail::vararg_< T > | 
|  | For defining variadic placeholders. 
 | 
|  | 
| template<typename... > | 
| using | void_ = void | 
|  | An alias for void.
 | 
|  | 
| template<list_like ListOfLists> | 
| using | 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<invocable Fn, list_like ListOfLists> | 
| using | 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...
 | 
|  |