|
using | ranges::v3::meta::placeholders::_args = vararg< void > |
|
using | ranges::v3::meta::placeholders::_args_a = vararg< _a > |
|
using | ranges::v3::meta::placeholders::_args_b = vararg< _b > |
|
using | ranges::v3::meta::placeholders::_args_c = vararg< _c > |
|
template<typename List , typename State , typename Fun > |
using | ranges::v3::meta::accumulate = fold< List, State, Fun > |
| An alias for meta::fold . More...
|
|
template<typename List , typename State , typename Fun > |
using | ranges::v3::meta::lazy::accumulate = defer< accumulate, List, State, Fun > |
|
template<class T > |
using | ranges::v3::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 | ranges::v3::meta::lazy::alignof_ = defer< alignof_, T > |
|
template<typename List , typename F > |
using | ranges::v3::meta::all_of = empty< find_if< List, compose< quote< not_ >, F >>> |
| A Boolean integral constant wrapper around true if apply<F, A>::value is true for all elements A in meta::list List ; false , otherwise. More...
|
|
template<typename List , typename Fn > |
using | ranges::v3::meta::lazy::all_of = defer< all_of, List, Fn > |
|
template<typename T > |
using | ranges::v3::meta::lazy::always = defer< always, T > |
|
template<typename... Bools> |
using | ranges::v3::meta::and_ = eval< meta_detail::_and_< Bools...>> |
| Logically and together all the integral constant-wrapped Boolean parameters, with short-circuiting.
|
|
template<typename... Bools> |
using | ranges::v3::meta::lazy::and_ = defer< and_, Bools...> |
|
template<bool... Bools> |
using | ranges::v3::meta::and_c = std::is_same< integer_sequence< bool, Bools...>, integer_sequence< bool,(Bools||true)...>> |
| Logically and together all the Boolean parameters.
|
|
template<typename List , typename F > |
using | ranges::v3::meta::any_of = not_< empty< find_if< List, F >>> |
| A Boolean integral constant wrapper around true if apply<F, A>::value is true for any element A in meta::list List ; false , otherwise. More...
|
|
template<typename List , typename Fn > |
using | ranges::v3::meta::lazy::any_of = defer< any_of, List, Fn > |
|
template<typename F , typename... Args> |
using | ranges::v3::meta::apply = typename F::template apply< Args...> |
| Evaluate the Metafunction Class F with the arguments Args .
|
|
template<typename F , typename... Args> |
using | ranges::v3::meta::lazy::apply = defer< apply, F, Args...> |
|
template<typename C , typename List > |
using | ranges::v3::meta::apply_list = eval< extension::apply_list< C, List >> |
| Applies the Metafunction Class C using the types in the type list List as arguments.
|
|
template<typename F , typename List > |
using | ranges::v3::meta::lazy::apply_list = defer< apply_list, F, List > |
|
template<typename Sequence > |
using | ranges::v3::meta::as_list = eval< meta_detail::as_list_< Sequence >> |
| Turn a type into an instance of meta::list in a way determined by meta::apply_list .
|
|
template<typename Sequence > |
using | ranges::v3::meta::lazy::as_list = defer< as_list, Sequence > |
|
template<typename List , typename N > |
using | ranges::v3::meta::at = eval< meta_detail::at_< List, N >> |
| Return the N th element in the meta::list List . More...
|
|
template<typename List , typename N > |
using | ranges::v3::meta::lazy::at = defer< at, List, N > |
|
template<typename List , std::size_t N> |
using | ranges::v3::meta::at_c = at< List, meta::size_t< N >> |
| Return the N th element in the meta::list List . More...
|
|
template<typename List > |
using | ranges::v3::meta::back = eval< meta_detail::back_< List >> |
| Return the last element in meta::list List . More...
|
|
template<typename List > |
using | ranges::v3::meta::lazy::back = defer< back, List > |
|
template<typename Fn , typename... Ts> |
using | ranges::v3::meta::lazy::bind_back = defer< bind_back, Fn, Ts...> |
|
template<typename Fn , typename... Ts> |
using | ranges::v3::meta::lazy::bind_front = defer< bind_front, Fn, Ts...> |
|
template<typename T , typename U > |
using | ranges::v3::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::value and U::type::value .
|
|
template<typename T , typename U > |
using | ranges::v3::meta::lazy::bit_and = defer< bit_and, T, U > |
|
template<typename T > |
using | ranges::v3::meta::bit_not = std::integral_constant< decltype(~T::type::value),~T::type::value > |
| An integral constant wrapper around the result of bitwise-complimenting the wrapped integer T::type::value .
|
|
template<typename T > |
using | ranges::v3::meta::lazy::bit_not = defer< bit_not, T > |
|
template<typename T , typename U > |
using | ranges::v3::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::value and U::type::value .
|
|
template<typename T , typename U > |
using | ranges::v3::meta::lazy::bit_or = defer< bit_or, T, U > |
|
template<typename T , typename U > |
using | ranges::v3::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::value and U::type::value .
|
|
template<typename T , typename U > |
using | ranges::v3::meta::lazy::bit_xor = defer< bit_xor, T, U > |
|
template<bool B> |
using | ranges::v3::meta::bool_ = std::integral_constant< bool, B > |
| An integral constant wrapper for bool .
|
|
template<typename ListOfLists > |
using | ranges::v3::meta::cartesian_product = reverse_fold< ListOfLists, list< list<>>, quote_trait< meta_detail::cartesian_product_fn >> |
| 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. More...
|
|
template<typename ListOfLists > |
using | ranges::v3::meta::lazy::cartesian_product = defer< cartesian_product, ListOfLists > |
|
template<char Ch> |
using | ranges::v3::meta::char_ = std::integral_constant< char, Ch > |
| An integral constant wrapper for char .
|
|
template<typename... Fns> |
using | ranges::v3::meta::lazy::compose = defer< compose, Fns...> |
|
template<typename... Lists> |
using | ranges::v3::meta::concat = eval< meta_detail::concat_< Lists...>> |
| Concatenates several lists into a single list. More...
|
|
template<typename... Lists> |
using | ranges::v3::meta::lazy::concat = defer< concat, Lists...> |
|
template<typename List , typename T > |
using | ranges::v3::meta::count = fold< List, meta::size_t< 0 >, bind_back< quote< meta_detail::count_fn >, T >> |
| Count the number of times a type T appears in the list List . More...
|
|
template<typename List , typename T > |
using | ranges::v3::meta::lazy::count = defer< count, List, T > |
|
template<typename State , typename Val , typename T > |
using | ranges::v3::meta::meta_detail::count_fn = if_< std::is_same< Val, T >, inc< State >, State > |
|
template<typename List , typename Fn > |
using | ranges::v3::meta::count_if = fold< List, meta::size_t< 0 >, bind_back< quote< meta_detail::count_if_fn >, Fn >> |
| Count the number of times the predicate Fn evaluates to true for all the elements in the list List . More...
|
|
template<typename List , typename Fn > |
using | ranges::v3::meta::lazy::count_if = defer< count_if, List, Fn > |
|
template<typename State , typename Val , typename Fn > |
using | ranges::v3::meta::meta_detail::count_if_fn = if_< apply< Fn, Val >, inc< State >, State > |
|
template<typename F , typename Q = quote<list>> |
using | ranges::v3::meta::curry = compose< F, Q > |
| A Metafunction Class that takes a bunch of arguments, bundles them into a type list, and then calls the Metafunction Class F with the type list Q .
|
|
template<typename F , typename Q = quote<list>> |
using | ranges::v3::meta::lazy::curry = defer< curry, F, Q > |
|
template<typename T > |
using | ranges::v3::meta::dec = std::integral_constant< decltype(T::type::value), T::type::value-1 > |
| An integral constant wrapper around the result of decrementing the wrapped integer T::type::value .
|
|
template<typename T > |
using | ranges::v3::meta::lazy::dec = defer< dec, T > |
|
template<template< typename...> class C, typename... Ts> |
using | ranges::v3::meta::defer_trait = lazy::eval< defer< C, Ts...>> |
| A wrapper that defers the instantiation of a trait C with type parameters Ts in a lambda or let expression. More...
|
|
template<typename T , template< T...> class C, T... Is> |
using | ranges::v3::meta::defer_trait_i = lazy::eval< 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. More...
|
|
template<typename T , typename U > |
using | ranges::v3::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::value and U::type::value .
|
|
template<typename T , typename U > |
using | ranges::v3::meta::lazy::divides = defer< divides, T, U > |
|
template<typename List , typename N > |
using | ranges::v3::meta::drop = eval< meta_detail::drop_< List, N >> |
| Return a new meta::list by removing the first N elements from List . More...
|
|
template<typename List , typename N > |
using | ranges::v3::meta::lazy::drop = defer< drop, List, N > |
|
template<typename List , std::size_t N> |
using | ranges::v3::meta::drop_c = eval< meta_detail::drop_< List, meta::size_t< N >>> |
| Return a new meta::list by removing the first N elements from List . More...
|
|
template<typename List > |
using | ranges::v3::meta::empty = bool_< 0==size< List >::type::value > |
| An Boolean integral constant wrapper around true if List is an empty type list; false , otherwise.
|
|
template<typename List > |
using | ranges::v3::meta::lazy::empty = defer< empty, List > |
|
template<typename T , typename U > |
using | ranges::v3::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 | ranges::v3::meta::lazy::equal_to = defer< equal_to, T, U > |
|
template<typename T > |
using | ranges::v3::meta::eval = typename T::type |
| "Evaluate" the trait T by returning the nested T::type alias.
|
|
template<typename T > |
using | ranges::v3::meta::lazy::eval = defer< eval, T > |
|
template<typename... Bools> |
using | ranges::v3::meta::fast_and = and_c< Bools::type::value...> |
| Logically and together all the integral constant-wrapped Boolean parameters, without doing short-circuiting.
|
|
template<typename... Bools> |
using | ranges::v3::meta::lazy::fast_and = defer< fast_and, Bools...> |
|
template<typename... Bools> |
using | ranges::v3::meta::fast_or = or_c< Bools::type::value...> |
| Logically or together all the integral constant-wrapped Boolean parameters, without doing short-circuiting.
|
|
template<typename... Bools> |
using | ranges::v3::meta::lazy::fast_or = defer< fast_or, Bools...> |
|
template<typename List , typename Predicate > |
using | ranges::v3::meta::filter = fold< List, list<>, meta_detail::filter_< Predicate >> |
| Returns a new meta::list where only those elements of List A that satisfy the Metafunction Class Predicate such that apply<Pred,A>::value is true are present. That is, those elements that don't satisfy the Predicate are "removed".
|
|
template<typename List , typename Predicate > |
using | ranges::v3::meta::lazy::filter = defer< filter, List, Predicate > |
|
template<typename List , typename T > |
using | ranges::v3::meta::find = eval< meta_detail::find_< List, T >> |
| Return the tail of the list List starting at the first occurrence of T , if any such element exists; the empty list, otherwise.
|
|
template<typename List , typename T > |
using | ranges::v3::meta::lazy::find = defer< find, List, T > |
|
template<typename List , typename Fun > |
using | ranges::v3::meta::find_if = eval< meta_detail::find_if_< List, Fun >> |
| Return the tail of the list List starting at the first element A such that apply<Fun, A>::value is true , if any such element exists; the empty list, otherwise.
|
|
template<typename List , typename Fun > |
using | ranges::v3::meta::lazy::find_if = defer< find_if, List, Fun > |
|
template<typename List , typename T > |
using | ranges::v3::meta::find_index = eval< meta_detail::find_index_< List, T >> |
| Finds the index of the first occurrence of the type T within the list List . Returns #meta::npos if the type T was not found. More...
|
|
template<typename List , typename T > |
using | ranges::v3::meta::lazy::find_index = defer< find_index, List, T > |
|
template<typename F > |
using | ranges::v3::meta::lazy::flip = defer< flip, F > |
|
template<typename List , typename State , typename Fun > |
using | ranges::v3::meta::fold = eval< meta_detail::fold_< List, State, Fun >> |
| Return a new meta::list constructed by doing a left fold of the list List using binary Metafunction Class Fun and initial state State . More...
|
|
template<typename List , typename State , typename Fun > |
using | ranges::v3::meta::lazy::fold = defer< fold, List, State, Fun > |
|
template<typename List > |
using | ranges::v3::meta::front = eval< meta_detail::front_< List >> |
| Return the first element in meta::list List . More...
|
|
template<typename List > |
using | ranges::v3::meta::lazy::front = defer< front, List > |
|
template<typename T , typename U > |
using | ranges::v3::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 | ranges::v3::meta::lazy::greater = defer< greater, T, U > |
|
template<typename T , typename U > |
using | ranges::v3::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 | ranges::v3::meta::lazy::greater_equal = defer< greater_equal, T, U > |
|
template<typename T > |
using | ranges::v3::meta::has_type = eval< meta_detail::has_type_< T >> |
| An alias for std::true_type if T::type exists and names a type; otherwise, it's an alias for std::false_type .
|
|
template<typename T > |
using | ranges::v3::meta::lazy::id = defer< id, T > |
|
template<typename T > |
using | ranges::v3::meta::id_t = eval< id< T >> |
| An alias that is type T . Useful in non-deduced contexts.
|
|
template<typename... Args> |
using | ranges::v3::meta::if_ = eval< meta_detail::_if_< Args...>> |
| Select one type or another depending on a compile-time Boolean.
|
|
template<typename... Args> |
using | ranges::v3::meta::lazy::if_ = defer< if_, Args...> |
|
template<bool If, typename... Args> |
using | ranges::v3::meta::if_c = eval< meta_detail::_if_< bool_< If >, Args...>> |
| Select one type or another depending on a compile-time Boolean.
|
|
template<bool If, typename... Args> |
using | ranges::v3::meta::lazy::if_c = if_< bool_< If >, Args...> |
|
template<typename List , typename T > |
using | ranges::v3::meta::in = not_< empty< find< List, T >>> |
| A Boolean integral constant wrapper around true if there is at least one occurrence of T in List .
|
|
template<typename List , typename T > |
using | ranges::v3::meta::lazy::in = defer< in, List, T > |
|
template<typename T > |
using | ranges::v3::meta::inc = std::integral_constant< decltype(T::type::value), T::type::value+1 > |
| An integral constant wrapper around the result of incrementing the wrapped integer T::type::value .
|
|
template<typename T > |
using | ranges::v3::meta::lazy::inc = defer< inc, T > |
|
template<int I> |
using | ranges::v3::meta::int_ = std::integral_constant< int, I > |
| An integral constant wrapper for int .
|
|
template<typename T > |
using | ranges::v3::meta::is_valid = meta_detail::is_valid_< T > |
| For testing whether a deferred computation will succeed in a let or a lambda .
|
|
template<typename ListOfLists > |
using | ranges::v3::meta::join = apply_list< quote< concat >, ListOfLists > |
| Joins a list of lists into a single list. More...
|
|
template<typename ListOfLists > |
using | ranges::v3::meta::lazy::join = defer< join, ListOfLists > |
|
template<typename... Ts> |
using | ranges::v3::meta::lambda = if_c<(sizeof...(Ts) > 0), meta_detail::lambda_< list< Ts...>>> |
| For creating anonymous Metafunction Classes. More...
|
|
template<typename... Ts> |
using | ranges::v3::meta::lambda_rec = meta_detail::lambda_rec_< list< Ts...>> |
| For defining a self-recursive lambda. In the body of a lambda, the placeholder _self refers to the nearest enclosing lambda_rec More...
|
|
template<typename T , typename U > |
using | ranges::v3::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 | ranges::v3::meta::lazy::less = defer< less, T, U > |
|
template<typename T , typename U > |
using | ranges::v3::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 T , typename U > |
using | ranges::v3::meta::lazy::less_equal = defer< less_equal, T, U > |
|
template<typename... As> |
using | ranges::v3::meta::let = eval< meta_detail::eval_let_< eval< meta_detail::let_< As...>>>> |
| A lexically scoped expression with local variables. More...
|
|
template<typename... As> |
using | ranges::v3::meta::lazy::let = defer< let, As...> |
|
template<typename T , typename U > |
using | ranges::v3::meta::max = if_< less< U, T >, T, U > |
| An integral constant wrapper around the maximum of T::type::value and U::type::value .
|
|
template<typename T , typename U > |
using | ranges::v3::meta::lazy::max = defer< max, T, U > |
|
template<typename T , typename U > |
using | ranges::v3::meta::min = if_< less< U, T >, U, T > |
| An integral constant wrapper around the minimum of T::type::value and U::type::value .
|
|
template<typename T , typename U > |
using | ranges::v3::meta::lazy::min = defer< min, T, U > |
|
template<typename T , typename U > |
using | ranges::v3::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::value and U::type::value .
|
|
template<typename T , typename U > |
using | ranges::v3::meta::lazy::minus = defer< minus, T, U > |
|
template<typename T , typename U > |
using | ranges::v3::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::value and U::type::value .
|
|
template<typename T , typename U > |
using | ranges::v3::meta::lazy::modulus = defer< modulus, T, U > |
|
template<typename T , typename U > |
using | ranges::v3::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::value and U::type::value .
|
|
template<typename T , typename U > |
using | ranges::v3::meta::lazy::multiplies = defer< multiplies, T, U > |
|
template<typename T > |
using | ranges::v3::meta::negate = std::integral_constant< decltype(-T::type::value),-T::type::value > |
| An integral constant wrapper around the remainder of dividing the two wrapped integers T::type::value and U::type::value .
|
|
template<typename T > |
using | ranges::v3::meta::lazy::negate = defer< negate, T > |
|
template<typename List , typename F > |
using | ranges::v3::meta::none_of = empty< find_if< List, F >> |
| A Boolean integral constant wrapper around true if apply<F, A>::value is false for alls elements A in meta::list List ; false , otherwise. More...
|
|
template<typename List , typename Fn > |
using | ranges::v3::meta::lazy::none_of = defer< none_of, List, Fn > |
|
template<typename Bool > |
using | ranges::v3::meta::not_ = not_c< Bool::type::value > |
| Logically negate the integral constant-wrapped Boolean parameter.
|
|
template<typename Bool > |
using | ranges::v3::meta::lazy::not_ = defer< not_, Bool > |
|
template<bool Bool> |
using | ranges::v3::meta::not_c = bool_<!Bool > |
| Logically negate the Boolean parameter.
|
|
template<typename T , typename U > |
using | ranges::v3::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 T , typename U > |
using | ranges::v3::meta::lazy::not_equal_to = defer< not_equal_to, T, U > |
|
using | ranges::v3::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... Bools> |
using | ranges::v3::meta::or_ = eval< meta_detail::_or_< Bools...>> |
| Logically or together all the integral constant-wrapped Boolean parameters, with short-circuiting.
|
|
template<typename... Bools> |
using | ranges::v3::meta::lazy::or_ = defer< or_, Bools...> |
|
template<bool... Bools> |
using | ranges::v3::meta::or_c = not_< std::is_same< integer_sequence< bool, Bools...>, integer_sequence< bool,(Bools &&false)...>>> |
| Logically or together all the Boolean parameters.
|
|
template<typename T , typename U > |
using | ranges::v3::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::value and U::type::value .
|
|
template<typename T , typename U > |
using | ranges::v3::meta::lazy::plus = defer< plus, T, U > |
|
template<typename List > |
using | ranges::v3::meta::pop_front = eval< meta_detail::pop_front_< List >> |
| Return a new meta::list by removing the first element from the front of List . More...
|
|
template<typename List > |
using | ranges::v3::meta::lazy::pop_front = defer< pop_front, List > |
|
template<typename List , typename T > |
using | ranges::v3::meta::push_back = eval< meta_detail::push_back_< List, T >> |
| Return a new meta::list by adding the element T to the back of List . More...
|
|
template<typename List , typename T > |
using | ranges::v3::meta::lazy::push_back = defer< push_back, List, T > |
|
template<typename List , typename T > |
using | ranges::v3::meta::push_front = eval< meta_detail::push_front_< List, T >> |
| Return a new meta::list by adding the element T to the front of List . More...
|
|
template<typename List , typename T > |
using | ranges::v3::meta::lazy::push_front = defer< push_front, List, T > |
|
template<typename N , typename T = void> |
using | ranges::v3::meta::repeat_n = eval< meta_detail::repeat_n_c_< N::type::value, T >> |
| Generate list<T,T,T...T> of size N arguments. More...
|
|
template<typename N , typename T = void> |
using | ranges::v3::meta::lazy::repeat_n = defer< repeat_n, N, T > |
|
template<std::size_t N, typename T = void> |
using | ranges::v3::meta::repeat_n_c = eval< meta_detail::repeat_n_c_< N, T >> |
| Generate list<T,T,T...T> of size N arguments. More...
|
|
template<typename List , typename T , typename U > |
using | ranges::v3::meta::replace = eval< meta_detail::replace_< List, T, U >> |
| Return a new meta::list where all instances of type T have been replaced with U . More...
|
|
template<typename List , typename T , typename U > |
using | ranges::v3::meta::lazy::replace = defer< replace, T, U > |
|
template<typename List , typename C , typename U > |
using | ranges::v3::meta::replace_if = eval< meta_detail::replace_if_< List, C, U >> |
| Return a new meta::list where all elements A of the list List for which apply<C,A>::value is true have been replaced with U . More...
|
|
template<typename List , typename C , typename U > |
using | ranges::v3::meta::lazy::replace_if = defer< replace_if, C, U > |
|
template<typename List > |
using | ranges::v3::meta::reverse = reverse_fold< List, list<>, quote< push_back >> |
| Return a new meta::list by reversing the elements in the list List . More...
|
|
template<typename List > |
using | ranges::v3::meta::lazy::reverse = defer< reverse, List > |
|
template<typename List , typename T > |
using | ranges::v3::meta::reverse_find = eval< meta_detail::reverse_find_< List, T >> |
| Return the tail of the list List starting at the last occurrence of T , if any such element exists; the empty list, otherwise.
|
|
template<typename List , typename T > |
using | ranges::v3::meta::lazy::reverse_find = defer< reverse_find, List, T > |
|
template<typename List , typename Fun > |
using | ranges::v3::meta::reverse_find_if = eval< meta_detail::reverse_find_if_< List, Fun >> |
| Return the tail of the list List starting at the last element A such that apply<Fun, A>::value is true , if any such element exists; the empty list, otherwise.
|
|
template<typename List , typename Fun > |
using | ranges::v3::meta::lazy::reverse_find_if = defer< reverse_find_if, List, Fun > |
|
template<typename List , typename T > |
using | ranges::v3::meta::reverse_find_index = eval< meta_detail::reverse_find_index_< List, T >> |
| Finds the index of the last occurrence of the type T within the list List . Returns #meta::npos if the type T was not found. More...
|
|
template<typename List , typename T > |
using | ranges::v3::meta::lazy::reverse_find_index = defer< reverse_find_index, List, T > |
|
template<typename List , typename State , typename Fun > |
using | ranges::v3::meta::reverse_fold = eval< meta_detail::reverse_fold_< List, State, Fun >> |
| Return a new meta::list constructed by doing a right fold of the list List using binary Metafunction Class Fun and initial state State . More...
|
|
template<typename List , typename State , typename Fun > |
using | ranges::v3::meta::lazy::reverse_fold = defer< reverse_fold, List, State, Fun > |
|
template<typename List > |
using | ranges::v3::meta::size = meta::size_t< List::size()> |
| An integral constant wrapper that is the size of the meta::list List .
|
|
template<typename List > |
using | ranges::v3::meta::lazy::size = defer< size, List > |
|
template<std::size_t N> |
using | ranges::v3::meta::size_t = std::integral_constant< std::size_t, N > |
| An integral constant wrapper for std::size_t .
|
|
template<class T > |
using | ranges::v3::meta::sizeof_ = meta::size_t< sizeof(T)> |
| An alias that computes the size of the type T . More...
|
|
template<typename T > |
using | ranges::v3::meta::lazy::sizeof_ = defer< sizeof_, T > |
|
template<typename... Args> |
using | ranges::v3::meta::transform = eval< meta_detail::transform_< Args...>> |
| Return a new meta::list constructed by transforming all the elements in List with the unary Metafuncion Class Fun . transform can also be called with two lists of the same length and a binary Metafunction Class, in which case it returns a new list constructed with the results of calling Fun with each element in the lists, pairwise. More...
|
|
template<typename... Args> |
using | ranges::v3::meta::lazy::transform = defer< transform, Args...> |
|
template<typename F > |
using | ranges::v3::meta::uncurry = bind_front< quote< apply_list >, F > |
| A Metafunction Class that takes a type list, unpacks the types, and then calls the Metafunction Class F with the types.
|
|
template<typename F > |
using | ranges::v3::meta::lazy::uncurry = defer< uncurry, F > |
|
template<typename List > |
using | ranges::v3::meta::unique = fold< List, list<>, quote_trait< meta_detail::insert_back_ >> |
| Return a new meta::list where all duplicate elements have been removed. More...
|
|
template<typename List > |
using | ranges::v3::meta::lazy::unique = defer< unique, List > |
|
template<typename T > |
using | ranges::v3::meta::vararg = meta_detail::vararg_< T > |
| For defining variadic placeholders.
|
|
template<typename... Ts> |
using | ranges::v3::meta::void_ = apply< always< void >, Ts...> |
| An alias for void .
|
|
template<typename ListOfLists > |
using | ranges::v3::meta::zip = zip_with< quote< list >, 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. More...
|
|
template<typename ListOfLists > |
using | ranges::v3::meta::lazy::zip = defer< zip, ListOfLists > |
|
template<typename Fun , typename ListOfLists > |
using | ranges::v3::meta::zip_with = transform< fold< ListOfLists, repeat_n< size< front< ListOfLists >>, Fun >, bind_back< quote< transform >, quote< bind_front >>>, quote< apply >> |
| Given a list of lists ListOfLists of types and a Metafunction Class Fun , construct a new list by calling Fun with the elements from the lists pairwise. More...
|
|
template<typename Fun , typename ListOfLists > |
using | ranges::v3::meta::lazy::zip_with = defer< zip_with, Fun, ListOfLists > |
|