hpx/type_support/meta.hpp

See Public API for a list of names and headers that are part of the public HPX API.

namespace hpx
namespace meta

Typedefs

template<typename T>
using type = typename T::type
template<typename T>
using hidden = meta::type<detail::hidden<T>>
template<typename T>
using identity = T
template<typename F, typename ...Ts>
using invoke = typename F::template apply<Ts...>
template<typename F, typename T1>
using invoke1 = typename F::template apply<T1>
template<typename F, typename T1, typename T2>
using invoke2 = typename F::template apply<T1, T2>
template<typename F, typename T1, typename T2, typename T3>
using invoke3 = typename F::template apply<T1, T2, T3>
template<template<class...> typename T, typename ...Ts>
using is_valid = util::is_detected<T, Ts...>
template<template<class> typename T, typename T1>
using is_valid1 = util::is_detected<T, T1>
template<template<class, class> typename T, typename T1, typename T2>
using is_valid2 = util::is_detected<T, T1, T2>
template<template<class, class, class> typename T, typename T1, typename T2, typename T3>
using is_valid3 = util::is_detected<T, T1, T2, T3>
template<typename F, typename ...Ts>
using is_invocable = is_valid<F::template apply, Ts...>
template<typename F, typename T1>
using is_invocable1 = is_valid1<F::template apply, T1>
template<typename F, typename T1, typename T2>
using is_invocable2 = is_valid2<F::template apply, T1, T2>
template<typename F, typename T1, typename T2, typename T3>
using is_invocable3 = is_valid3<F::template apply, T1, T2, T3>
template<typename F, typename ...Front>
using bind_front = bind_front_func<F::template apply, Front...>
template<typename F, typename ...Back>
using bind_front1 = bind_front1_func<F::template apply, Back...>
template<typename F, typename ...Back>
using bind_front2 = bind_front2_func<F::template apply, Back...>
template<typename F, typename ...Back>
using bind_front3 = bind_front3_func<F::template apply, Back...>
template<typename F, typename ...Back>
using bind_back = bind_back_func<F::template apply, Back...>
template<typename F, typename ...Back>
using bind_back1 = bind_back1_func<F::template apply, Back...>
template<typename F, typename ...Back>
using bind_back2 = bind_back2_func<F::template apply, Back...>
template<typename F, typename ...Back>
using bind_back3 = bind_back3_func<F::template apply, Back...>
template<typename Cond, typename TrueCase, typename FalseCase>
using if_ = invoke2<detail::if_<value<Cond>>, TrueCase, FalseCase>
template<bool Value>
using bool_ = std::bool_constant<Value>
template<typename Bool>
using not_ = bool_<!value<Bool>>
template<typename T0, typename T1>
using or_ = bool_<(value<T0> || value<T1>)>
template<typename T0, typename T1>
using and_ = bool_<(value<T0> && value<T1>)>
template<typename F = func<pack>>
using uncurry = compose_args<F>
template<typename F, typename ...List>
using apply = invoke<uncurry<F>, List...>
template<typename T, typename ...Ts>
using one_of = invoke<contains<T>, Ts...>
template<typename T, typename ...Ts>
using none_of = invoke<contains<T, not_pred<func<std::is_same>>>, Ts...>

Variables

template<typename T>
constexpr bool value<std::is_same<T, T>> = T::value
template<template<class...> typename F, typename ...Back>
struct bind_back1_func

Public Types

template<typename A>
using apply = F<A, Back...>
template<template<class...> typename F, typename ...Back>
struct bind_back2_func

Public Types

template<typename A, typename B>
using apply = F<A, B, Back...>
template<template<class...> typename F, typename ...Back>
struct bind_back3_func

Public Types

template<typename A, typename B, typename C>
using apply = F<A, B, C, Back...>
template<template<class...> typename F, typename ...Back>
struct bind_back_func

Public Types

template<typename ...Ts>
using apply = F<Ts..., Back...>
template<template<class...> typename F, typename ...Front>
struct bind_front1_func

Public Types

template<typename A>
using apply = F<Front..., A>
template<template<class...> typename F, typename ...Front>
struct bind_front2_func

Public Types

template<typename A, typename B>
using apply = F<Front..., A, B>
template<template<class...> typename F, typename ...Front>
struct bind_front3_func

Public Types

template<typename A, typename B, typename C>
using apply = F<Front..., A, B, C>
template<template<class...> typename F, typename ...Front>
struct bind_front_func

Public Types

template<typename ...Ts>
using apply = F<Front..., Ts...>
template<typename F = func<pack>>
struct compose_args

Public Types

template<typename ...Ts>
using apply = type<detail::compose_args_helper<F, pack<Ts...>>>
template<typename R>
struct compose_func

Public Types

template<typename ...Ts>
using apply = R(Ts...)
template<typename T>
struct constant

Public Types

template<typename...>
using apply = T
template<typename T, typename Cmp = func<std::is_same>>
struct contains

Public Types

template<typename ...Ts>
using apply = invoke<func<util::any_of>, invoke2<Cmp, T, Ts>...>
struct count

Public Types

template<typename ...Ts>
using apply = std::integral_constant<std::size_t, sizeof...(Ts)>
template<typename F>
struct curry

Public Types

template<typename ...Ts>
using apply = invoke<F, Ts...>
template<template<class...> typename F>
struct defer

Public Types

template<typename ...Ts>
using apply = type<detail::defer_helper<F, pack<Ts...>>>
template<template<class...> typename F>
struct func

Public Types

template<typename ...Ts>
using apply = F<Ts...>
template<template<class> typename F>
struct func1

Public Types

template<typename T1>
using apply = F<T1>
template<template<class, class> typename F>
struct func2

Public Types

template<typename T1, typename T2>
using apply = F<T1, T2>
template<template<class, class, class> typename F>
struct func3

Public Types

template<typename T1, typename T2, typename T3>
using apply = F<T1, T2, T3>
template<typename Pred = func<std::is_same>>
struct not_pred

Public Types

template<typename T1, typename T2>
using apply = not_<invoke<Pred, T1, T2>>
template<typename Continuation = func<pack>>
struct push_back

Public Types

template<typename List, typename ...Item>
using apply = meta::apply<bind_back<Continuation, Item...>, List>
template<typename Continuation = func<pack>>
struct push_back_unique

Public Types

template<typename List, typename Item>
using apply = meta::apply<if_<meta::apply<contains<Item>, List>, Continuation, bind_back<Continuation, Item>>, List>
template<typename Old, typename Continuation = func<pack>>
struct remove

Public Types

template<typename ...Ts>
using apply = invoke<compose_args<Continuation>, if_<std::is_same<Ts, Old>, pack<>, pack<Ts>>...>
template<typename Old, typename New, typename Continuation = func<pack>>
struct replace

Public Types

template<typename ...Ts>
using apply = invoke<Continuation, if_<std::is_same<Ts, Old>, New, Ts>...>
template<typename Init, typename F>
struct right_fold

Public Types

template<typename ...Ts>
using apply = type<detail::right_fold_helper<F, pack<Init, Ts...>>>
template<typename F, typename Continuation = func<pack>>
struct transform

Public Types

template<typename ...Ts>
using apply = invoke<Continuation, invoke1<F, Ts>...>
template<typename Continuation = func<pack>>
struct unique

Public Types

template<typename ...Ts>
using apply = meta::apply<Continuation, invoke<right_fold<pack<>, push_back_unique<>>, Ts...>>