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.