Lazy versions of meta actions. More...
Typedefs | |
template<typename T > | |
using | _t = defer<_t, T> |
template<typename L , typename State , typename Fn > | |
using | accumulate = defer<accumulate, L, State, Fn> |
template<typename T > | |
using | alignof_ = defer<alignof_, T> |
template<typename L , typename Fn > | |
using | all_of = defer<all_of, L, Fn> |
template<typename... Bs> | |
using | and_ = defer<and_, Bs...> |
template<typename L , typename Fn > | |
using | any_of = defer<any_of, L, Fn> |
template<typename Fn , typename L > | |
using | apply = defer<apply, Fn, L> |
template<typename Sequence > | |
using | as_list = defer<as_list, Sequence> |
template<typename L , typename N > | |
using | at = defer<at, L, N> |
template<typename L > | |
using | back = defer<back, L> |
template<typename Fn , typename... Ts> | |
using | bind_back = defer<bind_back, Fn, Ts...> |
template<typename Fn , typename... Ts> | |
using | bind_front = defer<bind_front, Fn, Ts...> |
template<typename T , typename U > | |
using | bit_and = defer<bit_and, T, U> |
template<typename T > | |
using | bit_not = defer<bit_not, T> |
template<typename T , typename U > | |
using | bit_or = defer<bit_or, T, U> |
template<typename T , typename U > | |
using | bit_xor = defer<bit_xor, T, U> |
template<typename ListOfLists > | |
using | cartesian_product = defer<cartesian_product, ListOfLists> |
template<typename... Fns> | |
using | compose = defer<compose, Fns...> |
template<typename... Lists> | |
using | concat = defer<concat, Lists...> |
template<typename L , typename T > | |
using | count = defer<count, L, T> |
template<typename L , typename Fn > | |
using | count_if = defer<count_if, L, Fn> |
template<typename Fn , typename Q = quote<list>> | |
using | curry = defer<curry, Fn, Q> |
template<typename T > | |
using | dec = defer<dec, T> |
template<typename T , typename U > | |
using | divides = defer<divides, T, U> |
template<typename L , typename N > | |
using | drop = defer<drop, L, N> |
template<typename L > | |
using | empty = defer<empty, L> |
template<typename T , typename U > | |
using | equal_to = defer<equal_to, T, U> |
template<typename L , typename Fn > | |
using | filter = defer<filter, L, Fn> |
template<typename L , typename T > | |
using | find = defer<find, L, T> |
template<typename L , typename Fn > | |
using | find_if = defer<find_if, L, Fn> |
template<typename L , typename T > | |
using | find_index = defer<find_index, L, T> |
template<typename Pair > | |
using | first = defer<first, Pair> |
template<typename Fn > | |
using | flip = defer<flip, Fn> |
template<typename L , typename State , typename Fn > | |
using | fold = defer<fold, L, State, Fn> |
template<typename L > | |
using | front = defer<front, L> |
template<typename T , typename U > | |
using | greater = defer<greater, T, U> |
template<typename T , typename U > | |
using | greater_equal = defer<greater_equal, T, U> |
template<typename T > | |
using | id = defer<id, T> |
template<typename... Args> | |
using | if_ = defer<if_, Args...> |
template<bool If, typename... Args> | |
using | if_c = if_<bool_<If>, Args...> |
template<typename L , typename T > | |
using | in = defer<in, L, T> |
template<typename T > | |
using | inc = defer<inc, T> |
template<typename L > | |
using | inherit = defer<inherit, L> |
template<typename Fn , typename... Args> | |
using | invoke = defer<invoke, Fn, Args...> |
template<typename ListOfLists > | |
using | join = defer<join, ListOfLists> |
template<typename T , typename U > | |
using | less = defer<less, T, U> |
template<typename T , typename U > | |
using | less_equal = defer<less_equal, T, U> |
template<typename... As> | |
using | let = defer<let, As...> |
template<typename... Ts> | |
using | max = defer<max, Ts...> |
template<typename... Ts> | |
using | min = defer<min, Ts...> |
template<typename T , typename U > | |
using | minus = defer<minus, T, U> |
template<typename T , typename U > | |
using | modulus = defer<modulus, T, U> |
template<typename T , typename U > | |
using | multiplies = defer<multiplies, T, U> |
template<typename T > | |
using | negate = defer<negate, T> |
template<typename L , invocable Fn> | |
using | none_of = defer<none_of, L, Fn> |
template<typename B > | |
using | not_ = defer<not_, B> |
template<typename T , typename U > | |
using | not_equal_to = defer<not_equal_to, T, U> |
template<typename Fn > | |
using | not_fn = defer<not_fn, Fn> |
template<typename Fn , typename G > | |
using | on = defer<on, Fn, G> |
template<typename... Bs> | |
using | or_ = defer<or_, Bs...> |
template<typename L , typename Fn > | |
using | partition = defer<partition, L, Fn> |
template<typename T , typename U > | |
using | plus = defer<plus, T, U> |
template<typename L > | |
using | pop_front = defer<pop_front, L> |
template<typename... Ts> | |
using | push_back = defer<push_back, Ts...> |
template<typename... Ts> | |
using | push_front = defer<push_front, Ts...> |
template<typename N , typename T = void> | |
using | repeat_n = defer<repeat_n, N, T> |
template<std::size_t N, typename T = void> | |
using | repeat_n_c = defer<repeat_n, meta::size_t<N>, T> |
template<typename L , typename T , typename U > | |
using | replace = defer<replace, T, U> |
template<typename L , typename C , typename U > | |
using | replace_if = defer<replace_if, C, U> |
template<typename L > | |
using | reverse = defer<reverse, L> |
template<typename L , typename T > | |
using | reverse_find = defer<reverse_find, L, T> |
template<typename L , typename Fn > | |
using | reverse_find_if = defer<reverse_find_if, L, Fn> |
template<typename L , typename T > | |
using | reverse_find_index = defer<reverse_find_index, L, T> |
template<typename L , typename State , typename Fn > | |
using | reverse_fold = defer<reverse_fold, L, State, Fn> |
template<typename Pair > | |
using | second = defer<second, Pair> |
template<typename L > | |
using | size = defer<size, L> |
template<typename T > | |
using | sizeof_ = defer<sizeof_, T> |
template<typename L , typename Fn > | |
using | sort = defer<sort, L, Fn> |
template<typename... Bs> | |
using | strict_and = defer<strict_and, Bs...> |
template<typename... Bs> | |
using | strict_or = defer<strict_or, Bs...> |
template<typename... Args> | |
using | transform = defer<transform, Args...> |
template<typename ListOfLists > | |
using | transpose = defer<transpose, ListOfLists> |
template<typename Fn > | |
using | uncurry = defer<uncurry, Fn> |
template<typename L > | |
using | unique = defer<unique, L> |
template<typename ListOfLists > | |
using | zip = defer<zip, ListOfLists> |
template<typename Fn , typename ListOfLists > | |
using | zip_with = defer<zip_with, Fn, ListOfLists> |
Lazy versions of meta actions.