Range-v3
Range algorithms, views, and actions for the Standard Library
 
Loading...
Searching...
No Matches
meta::lazy Namespace Reference

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>
 

Detailed Description

Lazy versions of meta actions.