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

Typedefs

template<typename T , typename U >
using meta::lazy::bit_and = defer<bit_and, T, U>
 
template<typename T >
using meta::lazy::bit_not = defer<bit_not, T>
 
template<typename T , typename U >
using meta::lazy::bit_or = defer<bit_or, T, U>
 
template<typename T , typename U >
using meta::lazy::bit_xor = defer<bit_xor, T, U>
 
template<typename T >
using meta::lazy::dec = defer<dec, T>
 
template<typename T , typename U >
using meta::lazy::divides = defer<divides, T, U>
 
template<typename T , typename U >
using meta::lazy::equal_to = defer<equal_to, T, U>
 
template<typename T , typename U >
using meta::lazy::greater = defer<greater, T, U>
 
template<typename T , typename U >
using meta::lazy::greater_equal = defer<greater_equal, T, U>
 
template<typename T >
using meta::lazy::inc = defer<inc, T>
 
template<typename T , typename U >
using meta::lazy::less = defer<less, T, U>
 
template<typename T , typename U >
using meta::lazy::less_equal = defer<less_equal, T, U>
 
template<typename... Ts>
using meta::lazy::max = defer<max, Ts...>
 
template<typename... Ts>
using meta::lazy::min = defer<min, Ts...>
 
template<typename T , typename U >
using meta::lazy::minus = defer<minus, T, U>
 
template<typename T , typename U >
using meta::lazy::modulus = defer<modulus, T, U>
 
template<typename T , typename U >
using meta::lazy::multiplies = defer<multiplies, T, U>
 
template<typename T >
using meta::lazy::negate = defer<negate, T>
 
template<typename T , typename U >
using meta::lazy::not_equal_to = defer<not_equal_to, T, U>
 
template<typename T , typename U >
using meta::lazy::plus = defer<plus, T, U>
 

Detailed Description

Typedef Documentation

◆ bit_and

template<typename T , typename U >
using meta::lazy::bit_and = defer<bit_and, T, U>

#include <meta/meta.hpp>

See also
'meta::bit_and'

◆ bit_not

template<typename T >
using meta::lazy::bit_not = defer<bit_not, T>

#include <meta/meta.hpp>

See also
'meta::bit_not'

◆ bit_or

template<typename T , typename U >
using meta::lazy::bit_or = defer<bit_or, T, U>

#include <meta/meta.hpp>

See also
'meta::bit_or'

◆ bit_xor

template<typename T , typename U >
using meta::lazy::bit_xor = defer<bit_xor, T, U>

#include <meta/meta.hpp>

See also
'meta::bit_xor'

◆ dec

template<typename T >
using meta::lazy::dec = defer<dec, T>

#include <meta/meta.hpp>

See also
'meta::dec'

◆ divides

template<typename T , typename U >
using meta::lazy::divides = defer<divides, T, U>

#include <meta/meta.hpp>

See also
'meta::divides'

◆ equal_to

template<typename T , typename U >
using meta::lazy::equal_to = defer<equal_to, T, U>

#include <meta/meta.hpp>

See also
'meta::equal_to'

◆ greater

template<typename T , typename U >
using meta::lazy::greater = defer<greater, T, U>

#include <meta/meta.hpp>

See also
'meta::greater'

◆ greater_equal

template<typename T , typename U >
using meta::lazy::greater_equal = defer<greater_equal, T, U>

#include <meta/meta.hpp>

See also
'meta::greater_equal'

◆ inc

template<typename T >
using meta::lazy::inc = defer<inc, T>

#include <meta/meta.hpp>

See also
'meta::int'

◆ less

template<typename T , typename U >
using meta::lazy::less = defer<less, T, U>

#include <meta/meta.hpp>

See also
'meta::less'

◆ less_equal

template<typename T , typename U >
using meta::lazy::less_equal = defer<less_equal, T, U>

#include <meta/meta.hpp>

See also
'meta::less_equal'

◆ max

template<typename... Ts>
using meta::lazy::max = defer<max, Ts...>

#include <meta/meta.hpp>

See also
'meta::max'

◆ min

template<typename... Ts>
using meta::lazy::min = defer<min, Ts...>

#include <meta/meta.hpp>

See also
'meta::min'

◆ minus

template<typename T , typename U >
using meta::lazy::minus = defer<minus, T, U>

#include <meta/meta.hpp>

See also
'meta::minus'

◆ modulus

template<typename T , typename U >
using meta::lazy::modulus = defer<modulus, T, U>

#include <meta/meta.hpp>

See also
'meta::modulus'

◆ multiplies

template<typename T , typename U >
using meta::lazy::multiplies = defer<multiplies, T, U>

#include <meta/meta.hpp>

See also
'meta::multiplies'

◆ negate

template<typename T >
using meta::lazy::negate = defer<negate, T>

#include <meta/meta.hpp>

See also
'meta::negate'

◆ not_equal_to

template<typename T , typename U >
using meta::lazy::not_equal_to = defer<not_equal_to, T, U>

#include <meta/meta.hpp>

See also
'meta::not_equal_t'

◆ plus

template<typename T , typename U >
using meta::lazy::plus = defer<plus, T, U>

#include <meta/meta.hpp>

See also
'meta::plus'