Range-v3
Range algorithms, views, and actions for the Standard Library
meta::lazy Namespace Reference

Lazy versions of meta actions. More...

Typedefs

template<typename T >
using _t = defer< _t, T >
 
template<typename List , typename State , typename Fun >
using accumulate = defer< accumulate, List, State, Fun >
 
template<typename T >
using alignof_ = defer< alignof_, T >
 
template<typename List , typename Fn >
using all_of = defer< all_of, List, Fn >
 
template<typename... Bools>
using and_ = defer< and_, Bools... >
 
template<typename List , typename Fn >
using any_of = defer< any_of, List, Fn >
 
template<typename F , typename List >
using apply = defer< apply, F, List >
 
template<typename Sequence >
using as_list = defer< as_list, Sequence >
 
template<typename List , typename N >
using at = defer< at, List, N >
 
template<typename List >
using back = defer< back, List >
 
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 List , typename T >
using count = defer< count, List, T >
 
template<typename List , typename Fn >
using count_if = defer< count_if, List, Fn >
 
template<typename F , typename Q = quote<list>>
using curry = defer< curry, F, Q >
 
template<typename T >
using dec = defer< dec, T >
 
template<typename T , typename U >
using divides = defer< divides, T, U >
 
template<typename List , typename N >
using drop = defer< drop, List, N >
 
template<typename List >
using empty = defer< empty, List >
 
template<typename T , typename U >
using equal_to = defer< equal_to, T, U >
 
template<typename List , typename Pred >
using filter = defer< filter, List, Pred >
 
template<typename List , typename T >
using find = defer< find, List, T >
 
template<typename List , typename Fun >
using find_if = defer< find_if, List, Fun >
 
template<typename List , typename T >
using find_index = defer< find_index, List, T >
 
template<typename Pair >
using first = defer< first, Pair >
 
template<typename F >
using flip = defer< flip, F >
 
template<typename List , typename State , typename Fun >
using fold = defer< fold, List, State, Fun >
 
template<typename List >
using front = defer< front, List >
 
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 List , typename T >
using in = defer< in, List, T >
 
template<typename T >
using inc = defer< inc, T >
 
template<typename List >
using inherit = defer< inherit, List >
 
template<typename F , typename... Args>
using invoke = defer< invoke, F, 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 List , typename Fn >
using none_of = defer< none_of, List, Fn >
 
template<typename Bool_ >
using not_ = defer< not_, Bool_ >
 
template<typename T , typename U >
using not_equal_to = defer< not_equal_to, T, U >
 
template<typename F >
using not_fn = defer< not_fn, F >
 
template<typename F , typename G >
using on = defer< on, F, G >
 
template<typename... Bools>
using or_ = defer< or_, Bools... >
 
template<typename List , typename Pred >
using partition = defer< partition, List, Pred >
 
template<typename T , typename U >
using plus = defer< plus, T, U >
 
template<typename List >
using pop_front = defer< pop_front, List >
 
template<typename List , typename T >
using push_back = defer< push_back, List, T >
 
template<typename List , typename T >
using push_front = defer< push_front, List, T >
 
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 List , typename T , typename U >
using replace = defer< replace, T, U >
 
template<typename List , typename C , typename U >
using replace_if = defer< replace_if, C, U >
 
template<typename List >
using reverse = defer< reverse, List >
 
template<typename List , typename T >
using reverse_find = defer< reverse_find, List, T >
 
template<typename List , typename Fun >
using reverse_find_if = defer< reverse_find_if, List, Fun >
 
template<typename List , typename T >
using reverse_find_index = defer< reverse_find_index, List, T >
 
template<typename List , typename State , typename Fun >
using reverse_fold = defer< reverse_fold, List, State, Fun >
 
template<typename Pair >
using second = defer< second, Pair >
 
template<typename List >
using size = defer< size, List >
 
template<typename T >
using sizeof_ = defer< sizeof_, T >
 
template<typename List , typename Pred >
using sort = defer< sort, List, Pred >
 
template<typename... Bools>
using strict_and = defer< strict_and, Bools... >
 
template<typename... Bools>
using strict_or = defer< strict_or, Bools... >
 
template<typename... Args>
using transform = defer< transform, Args... >
 
template<typename ListOfLists >
using transpose = defer< transpose, ListOfLists >
 
template<typename F >
using uncurry = defer< uncurry, F >
 
template<typename List >
using unique = defer< unique, List >
 
template<typename ListOfLists >
using zip = defer< zip, ListOfLists >
 
template<typename Fun , typename ListOfLists >
using zip_with = defer< zip_with, Fun, ListOfLists >
 

Detailed Description

Lazy versions of meta actions.