Trait
Meta

Trait invocation/composition. More...

## Modules

| Invocation
| Trait invocation.
| Composition
| Trait composition.
| lazy

## Classes

struct | meta::id< T >
| A trait that always returns its argument `T`. It is also an invocable that always returns `T`. More...

## Typedefs

template<typename 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_valid = detail::is_valid_< T >
| For testing whether a deferred computation will succeed in a `let` or a `lambda`.
template<typename... As>
using | meta::let = _t< _t< detail::let_< As... > >>
| A lexically scoped expression with local variables. More...
template<invocable Fn>
using | meta::not_fn = compose< quote< not_ >, Fn >
| Logically negate the result of invocable `Fn`.
template<typename 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`.

## Functions

template<typename... Ts>
| meta::requires (sizeof...(Ts) > 0) using lambda
| For creating anonymous Invocables. More...

## Variables

template<typename , template< typename... > class>
constexpr bool | meta::is_v = false
| is_v Test whether a type `T` is an instantiation of class template `C`.

## Detailed Description

Trait invocation/composition.

## Typedef Documentation

## alignof_

template<typename 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`.

## 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 L>
using find_index_ = let<
var<_a, L>,
var<_b, lazy::find<_a, T>>,
lazy::if_<
std::is_same<_b, list<>>,
meta::npos,
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{}, "");
meta::lazy::if_
defer< if_, Args... > if_
Definition: meta.hpp:1258
meta::npos
meta::size_t< std::size_t(-1)> npos
A special value used to indicate no matches. It equals the maximum value representable by std::size_t...
Definition: meta.hpp:1676
meta::let
_t< _t< detail::let_< As... > >> let
A lexically scoped expression with local variables.
Definition: meta.hpp:3660

## sizeof_

template<typename 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)`.

## Function Documentation

## requires()

template<typename... Ts>

meta::requires | ( | sizeof... | Ts,
|  | 0 |
| ) |  |

`#include <meta/meta.hpp>`

For creating anonymous Invocables.

using L = lambda<_a, _b, std::pair<_b, std::pair<_a, _a>>>;
using P = invoke<L, int, short>;
static_assert(std::is_same_v<P, std::pair<short, std::pair<int, int>>>, "");
meta::pair
list< F, S > pair
A list with exactly two elements.
Definition: meta.hpp:2246

Referenced by ranges::back_fn::c(), ranges::front_fn::c(), ranges::index_fn::c(), and ranges::views::cycle_fn::c().