Range-v3
Range algorithms, views, and actions for the Standard Library
Trait

Description

Trait invocation/composition.

Modules

 Invocation
 Trait invocation.
 
 Composition
 Trait composition.
 
 lazy
 

Classes

struct  meta::id< T >
 A trait that always returns its argument T. Also, a Callable that always returns T. More...
 

Typedefs

template<class T >
using meta::alignof_ = meta::size_t< alignof(T)>
 An alias that computes the alignment required for any instance of the type T. More...
 
template<typename T >
using meta::id_t = _t< id< T > >
 An alias for type T. Useful in non-deduced contexts.
 
template<typename T , template< typename... > class C>
using meta::is = _t< detail::is_< T, C > >
 is More...
 
template<typename T >
using meta::is_callable = _t< detail::is_callable_< T > >
 An alias for std::true_type if T::invoke exists and names a class template or alias template; otherwise, it's an alias for std::false_type.
 
template<typename T >
using meta::is_trait = _t< detail::is_trait_< T > >
 An alias for std::true_type if T::type exists and names a type; otherwise, it's an alias for std::false_type.
 
template<typename T >
using meta::is_valid = detail::is_valid_< T >
 For testing whether a deferred computation will succeed in a let or a lambda.
 
template<typename... Ts>
using meta::lambda = if_c<(sizeof...(Ts) > 0), detail::lambda_< list< Ts... > >>
 For creating anonymous Callables. More...
 
template<typename... As>
using meta::let = _t< _t< detail::let_< As... > >>
 A lexically scoped expression with local variables. More...
 
template<typename F >
using meta::not_fn = compose< quote< not_ >, F >
 Logically negate the result of Callable F.
 
template<class T >
using meta::sizeof_ = meta::size_t< sizeof(T)>
 An alias that computes the size of the type T. More...
 
template<typename... >
using meta::void_ = void
 An alias for void.
 

Typedef Documentation

◆ alignof_

template<class T >
using meta::alignof_ = typedef meta::size_t<alignof(T)>

#include <meta/meta.hpp>

An alias that computes the alignment required for any instance of the type T.

Complexity
$ O(1) $.

◆ is

template<typename T , template< typename... > class C>
using meta::is = typedef _t<detail::is_<T, C> >

#include <meta/meta.hpp>

is

Test whether a type T is an instantiation of class template C.

◆ lambda

template<typename... Ts>
using meta::lambda = typedef if_c<(sizeof...(Ts) > 0), detail::lambda_<list<Ts...> >>

#include <meta/meta.hpp>

For creating anonymous Callables.

using L = lambda<_a, _b, std::pair<_b, std::pair<_a, _a>>>;
using P = invoke<L, int, short>;
static_assert(std::is_same<P, std::pair<short, std::pair<int, int>>>::value,
"");

◆ let

template<typename... As>
using meta::let = typedef _t<_t<detail::let_<As...> >>

#include <meta/meta.hpp>

A lexically scoped expression with local variables.

template <typename T, typename List>
using find_index_ = let<
var<_a, List>,
var<_b, lazy::find<_a, T>>,
std::is_same<_b, list<>>,
lazy::minus<lazy::size<_a>, lazy::size<_b>>>>;
static_assert(find_index_<int, list<short, int, float>>{} == 1, "");
static_assert(find_index_<double, list<short, int, float>>{} ==
meta::npos{}, "");

◆ sizeof_

template<class T >
using meta::sizeof_ = typedef meta::size_t<sizeof(T)>

#include <meta/meta.hpp>

An alias that computes the size of the type T.

Complexity
$ O(1) $.