typelist.h
Go to the documentation of this file.
#ifndef __utl_meta_typelist_h__
#define __utl_meta_typelist_h__
#include <utl/core/impl.h>
#include <utl/meta/integral.h>
#include <utl/meta/detection.h>
#include <utl/meta/invoke.h>
#include <utl/meta/sfinae.h>
namespace utl {
namespace meta {
template <typename... Ts>
struct typelist {
using type = typelist;
static constexpr size_t size() noexcept {
return sizeof...(Ts);
}
static constexpr bool empty() noexcept {
return (sizeof...(Ts) == 0);
}
// ======= times utility =======
private:
template <typename... > struct cat_ { };
template <typename... L1, typename... L2>
struct cat_<typelist<L1...>, typelist<L2...>> {
using type = typelist<L1..., L2...>;
};
template <size_t N, typename ...T>
struct times_ {
//static_assert( N >= 0, "Cannot make typelist of negative length" );
using type = eval<
cat_<
eval<times_<N/2, T...>>,
eval<times_<N - N/2, T...>>
>
>;
};
template <typename ...T>
struct times_<1, T...> {
using type = typelist<T...>;
};
template <typename ...T>
struct times_<0, T...> {
using type = typelist<>;
};
public:
template<size_t N>
using times = eval<
times_<N, Ts...>
>;
};
template <typename List>
using size = size_<List::size()>;
template <typename List>
using empty = bool_<List::empty()>;
template <typename T1, typename T2>
using pair = typelist<T1, T2>;
template <size_t N, typename ...Ts>
using repeat_c = typename typelist<Ts...>::template times<N>;
template <typename N, typename ...Ts>
using repeat = repeat_c<N::type::value, Ts...>;
namespace apply_impl {
template <typename Fn, typename Seq>
struct apply_ { };
template<typename Fn, typename ...List>
struct apply_<Fn, typelist<List...>> {
using type = invoke<Fn, List...>;
};
template <typename Fn, typename T, T... Is>
struct apply_<Fn, integer_sequence<T, Is...>> {
using type = invoke<Fn, integral_<T, Is>...>;
};
}
template <typename Fn, typename Seq>
using apply = apply_impl::apply_<Fn, Seq>;
template <typename Fn, typename Seq>
using apply_t = eval <apply<Fn, Seq>>;
/*
* ========= element access ========
*/
namespace at_impl {
template <typename T> struct _add_pointer { using type = T*; };
template <typename T> using add_pointer = eval < _add_pointer <T> >;
template <typename ...>
struct at_head_ { };
template <typename... voids>
struct at_head_ <typelist<voids...>> {
// successful selection N voids, one T* and the rest
template <typename T> static constexpr T select(voids..., T*, ...);
// selection on error
static constexpr nil_ select (...);
};
template<typename List, index_t N>
struct at_ { };
template<typename... List, index_t N>
struct at_<typelist<List...>, N> {
using head_ = at_head_<typelist<void*>::times<N>>; //< make at_head_<> with N void*
using type = decltype(
head_::select(static_cast< add_pointer<List> >(nullptr)...) //< pass all as List*...
);
};
}
template <typename List, index_t N>
using at_c = eval<
at_impl::at_<List, N>
>;
template <typename List, typename N>
using at = at_c<List, N::type::value>;
namespace front_impl {
template <typename L>
struct front_ { };
template <typename Head, typename... Tail>
struct front_<typelist<Head, Tail...>> {
using type = Head;
};
}
template <typename List>
using front = eval<
front_impl::front_<List>
>;
namespace back_impl {
template <typename List>
struct back_ { };
template <typename Head, typename... Tail>
struct back_<typelist<Head, Tail...>> {
using type = at_c <
typelist<Head, Tail...>, sizeof...(Tail)
>;
};
}
template <typename List>
using back = eval<
back_impl::back_<List>
>;
/*
* ========= typelist operations =========
*/
namespace cat_impl {
template <typename... Lists>
struct cat_ { };
template <>
struct cat_<> {
using type = typelist<>;
};
template <typename... L1>
struct cat_<typelist<L1...>> {
using type = typelist<L1...>;
};
template <typename... L1, typename... L2>
struct cat_<typelist<L1...>, typelist<L2...>> {
using type = typelist<L1..., L2...>;
};
template <typename... L1, typename... L2, typename... Ln>
struct cat_<typelist<L1...>, typelist<L2...>, Ln...>
: cat_ <typelist<L1..., L2...>, Ln...> { };
}
template <typename... Lists>
using cat = eval<
cat_impl::cat_<Lists...>
>;
namespace fold_impl {
// fold<<T1, T2, T3>, V, F> == F<F<F<V, T1>, T2>, T3>
template<typename, typename, typename>
struct fold_ { }; // ill formed
// recursive call
template<typename Head, typename... Tail,
typename V,
typename Fn>
struct fold_<typelist<Head, Tail...>, V, Fn> {
// recursive call of fold_ by consuming typelist and invoking Fn
using type = eval<
fold_<
typelist<Tail...>,
invoke<Fn, V, Head>,
Fn
>
>;
};
// termination call
template<typename V0, typename Fn>
struct fold_<typelist<>, V0, Fn> {
using type = V0;
};
}
template <typename List, typename V, typename Fn>
using fold = eval<fold_impl::fold_<List, V, Fn>>;
template <typename List, typename V, typename Fn>
using accumulate = fold<List, V, Fn>;
namespace rev_fold_impl {
// rev_fold<<T1, T2, T3>, V, F> == F<T1, F<T2, F<T3, V>>>
template<typename, typename, typename>
struct rev_fold_ { }; // ill formed
// recursive call
template<typename Head, typename... Tail,
typename V,
typename Fn>
struct rev_fold_<typelist<Head, Tail...>, V, Fn> {
// recursive call inside invoke. This way the 2nd argument of Fn
// becoming the recursive "thing", inside Fn<>
using type = invoke <
Fn, Head, eval<
rev_fold_ <
typelist<Tail...>,
V,
Fn
>>
>;
};
// pre-termination call
template<typename Tail, typename V, typename Fn>
struct rev_fold_ <typelist<Tail>, V, Fn> {
using type = invoke<Fn, Tail, V>;
};
// termination call
template<typename V, typename Fn>
struct rev_fold_ <typelist<>, V, Fn> {
using type = V;
};
}
template <typename List, typename V, typename Fn>
using rev_fold = eval<
rev_fold_impl::rev_fold_<List, V, Fn>
>;
template <typename List, typename... Ts>
using push_front = eval<
apply <
bind_front<quote<typelist>, Ts...>, List
>
>;
template <typename List, typename... Ts>
using push_back = eval<
apply <
bind_back<quote<typelist>, Ts...>, List
>
>;
namespace reverse_impl {
template <typename List, typename V = typelist<>>
struct reverse_ {
using type = fold<List, V, quote<push_front>>;
};
}
template <typename List>
using reverse = eval<
reverse_impl::reverse_<List>
>;
namespace pop_front_impl {
template <typename List>
struct pop_front_ { };
template <typename Head, typename... Tail>
struct pop_front_<typelist <Head, Tail...>> {
using type = typelist<Tail...>;
};
}
template <typename List>
using pop_front = eval<
pop_front_impl::pop_front_<List>
>;
namespace pop_back_impl {
template <typename List>
struct pop_back_ {
using type = reverse<
pop_front<reverse<List>>
>;
};
}
template <typename List>
using pop_back = eval <
pop_back_impl::pop_back_<List>
>;
namespace transform_impl {
template <typename, typename = void>
struct transform_ { };
template <typename... Ts, typename Fn>
struct transform_<typelist<typelist<Ts...>, Fn>,
void_t<invoke<Fn, Ts>...> > /* SFINAE check */ {
using type = typelist<
invoke_t<Fn, Ts>...
>;
};
template <typename... Ts0, typename... Ts1, typename Fn>
struct transform_<typelist<typelist<Ts0...>, typelist<Ts1...>, Fn>,
void_t<invoke<Fn, Ts0, Ts1>...>> /* SFINAE check */ {
using type = typelist<
invoke_t<Fn, Ts0, Ts1>...
>;
};
}
template <typename... Args>
using transform = eval<
transform_impl::transform_<typelist<Args...>>
>;
namespace transform_lazy_impl {
template <typename, typename = void>
struct transform_lazy_ { };
// Match for Unary Fn with one typelist
template <typename... Ts, typename Fn>
struct transform_lazy_<typelist<typelist<Ts...>, Fn>,
void_t<invoke<Fn, Ts>...> > /* SFINAE check */ {
using type = typelist<
invoke<Fn, Ts>...
>;
};
// Match for Binary Fn with two typelists
template <typename... Ts0, typename... Ts1, typename Fn>
struct transform_lazy_<typelist<typelist<Ts0...>, typelist<Ts1...>, Fn>,
void_t<invoke<Fn, Ts0, Ts1>...>> /* SFINAE check */ {
using type = typelist<
invoke<Fn, Ts0, Ts1>...
>;
};
}
template <typename... Args>
using transform_lazy = eval<
transform_lazy_impl::transform_lazy_<typelist<Args...>>
>;
namespace find_if_impl {
template <typename, typename, index_t>
struct find_if_ { };
template<typename Head, typename... Tail, typename Fn, index_t N>
struct find_if_<typelist<Head, Tail...>, Fn, N> {
// Recursive call to find_if_ until Fn returns true_
using type = if_ <
invoke_t<Fn, Head>,
index_<N>, // done, return current index
eval<find_if_< // not done, re-call find_if_ with the Tail...
typelist<Tail...>, Fn, N+1>
>
>;
};
// When empty or when we are one place after the last item return Npos
template<typename Fn, index_t N>
struct find_if_<typelist<>, Fn, N> {
using type = Npos;
};
}
template<typename List, typename Pred>
using find_if = eval<
find_if_impl::find_if_<List, Pred, 0>
>;
template <typename List, typename T>
using find = find_if<List, same_as<T>>;
namespace seek_if_impl {
template <typename, typename, index_t>
struct seek_if_ { };
template<typename Head, typename... Tail, typename Fn, index_t N>
struct seek_if_<typelist<Head, Tail...>, Fn, N> {
// recursive call to seek_if_ until Fn returns true_
using type = if_ <
invoke_t<Fn, Head>,
typelist<Head, Tail...>, // done, return the typelist starting from here
eval<seek_if_< // not done, re-call seek_if_ with the Tail...
typelist<Tail...>, Fn, N+1>
>
>;
};
// When empty or when we are one place after the last item return empty typelist
template<typename Fn, index_t N>
struct seek_if_<typelist<>, Fn, N> {
using type = typelist<>;
};
}
template <typename List, typename Pred>
using seek_if = eval<
seek_if_impl::seek_if_<List, Pred, 0>
>;
template <typename List, typename T>
using seek = seek_if <List, same_as<T>>;
namespace count_if_impl {
template <typename, typename, size_t>
struct count_if_ { };
template<typename Head, typename... Tail, typename Fn, size_t N>
struct count_if_<typelist<Head, Tail...>, Fn, N> {
// Recursive call to count_if_ up to the end of List, counting all invokes of Fn
// returning true_
using type = if_ <
invoke_t<Fn, Head>,
eval<
count_if_<typelist<Tail...>, Fn, N+1> // increase and re-call
>,
eval<
count_if_<typelist<Tail...>, Fn, N> // re-call without increasing
>
>;
};
// At the end of the List return the counter
template<typename Fn, size_t N>
struct count_if_<typelist<>, Fn, N> {
using type = size_<N>;
};
}
template <typename List, typename Pred>
using count_if = eval<
count_if_impl::count_if_<List, Pred, 0>
>;
template <typename List, typename T>
using count = count_if<List, same_as<T>>;
namespace filter_impl {
template <typename, typename, typename>
struct filter_ { };
template<typename Head, typename... Tail, typename Fn, typename L>
struct filter_<typelist<Head, Tail...>, Fn, L> {
// Recursive call to filter_ up to the end of the List, creating a new list
// of items for which the invoke of Fn returns true_
using type = if_ <
invoke_t <Fn, Head>,
eval<filter_<typelist<Tail...>, Fn, cat<L, typelist<Head>>>>, // Add the element and re-call
eval<filter_<typelist<Tail...>, Fn, L>> // re-call with the same list
>;
};
// At the end return the produced list
template<typename Fn, typename L>
struct filter_<typelist<>, Fn, L> {
using type = L;
};
}
template <typename List, typename Pred>
using filter = eval<
filter_impl::filter_<List, Pred, typelist<>>
>;
namespace replace_if_impl {
template <typename, typename, typename, typename>
struct replace_if_ { };
template <typename Head, typename... Tail, typename Fn, typename T, typename Ret>
struct replace_if_<typelist<Head, Tail...>, Fn, T, Ret> {
// Recursive call to replace_if_ up to the end of the List, creating a new list
// of items based on invocation of Fn
using type = if_ <
invoke_t<Fn, Head>,
eval<replace_if_<typelist<Tail...>, Fn, T, cat<Ret, typelist<T>>>>, // re-call with change to T
eval<replace_if_<typelist<Tail...>, Fn, T, cat<Ret, typelist<Head>>>> // re-call with no change
>;
};
// At the end return the produced list
template <typename Fn, typename T, typename Ret>
struct replace_if_ <typelist<>, Fn, T, Ret> {
using type = Ret;
};
}
template<typename List, typename Pred, typename T>
using replace_if = eval<
replace_if_impl::replace_if_<List, Pred, T, typelist<>>
>;
template <typename List, typename T, typename U>
using replace = eval <
replace_if <List, same_as<T>, U>
>;
template <typename List, typename Pred>
using all_of = if_ <
empty <List>,
false_,
empty <
filter <List, compose<quote<not_>, Pred>>
>
>;
template <typename List, typename Pred>
using any_of = not_<
empty<filter <List, Pred>>
>;
template <typename List, typename Pred>
using none_of = empty<
filter <List, Pred>
>;
}}
#endif /* __utl_meta_typelist_h__ */
utl::meta::accumulate
fold< List, V, Fn > accumulate
accumulate is an stl name for fold
Definition: typelist.h:387
utl::meta::fold_impl::fold_
Definition: typelist.h:347
invoke.h
utl::meta::none_of
empty< filter< List, Pred > > none_of
Definition: typelist.h:875
utl::meta::apply_impl::apply_< Fn, integer_sequence< T, Is... > >::type
invoke< Fn, integral_< T, Is >... > type
Definition: typelist.h:182
utl::meta::if_
if_c< If::type::value, Args... > if_
Select one type or another depending on a compile-time Boolean type.
Definition: selection.h:66
utl::meta::void_t
void void_t
void_t type alias
Definition: detection.h:55
utl::meta::count_if
eval< count_if_impl::count_if_< List, Pred, 0 > > count_if
Definition: typelist.h:755
utl::meta::filter
eval< filter_impl::filter_< List, Pred, typelist<> > > filter
Definition: typelist.h:800
utl::meta::at_c
eval< at_impl::at_< List, N > > at_c
Definition: typelist.h:245
utl::meta::typelist::times_::type
eval< cat_< eval< times_< N/2, T... > >, eval< times_< N - N/2, T... > > > > type
Definition: typelist.h:92
utl::meta::at_impl::add_pointer
eval< _add_pointer< T > > add_pointer
Definition: typelist.h:212
utl::meta::reverse_impl::reverse_
Definition: typelist.h:467
utl::meta::replace_if
eval< replace_if_impl::replace_if_< List, Pred, T, typelist<> > > replace_if
Definition: typelist.h:841
utl::meta::replace_if_impl::replace_if_< typelist< Head, Tail... >, Fn, T, Ret >::type
if_< invoke_t< Fn, Head >, eval< replace_if_< typelist< Tail... >, Fn, T, cat< Ret, typelist< T > >> >, eval< replace_if_< typelist< Tail... >, Fn, T, cat< Ret, typelist< Head > >> > > type
Definition: typelist.h:817
utl::meta::size
size_< List::size()> size
Definition: typelist.h:129
utl::meta::count_if_impl::count_if_
Definition: typelist.h:718
utl::meta::push_back
eval< apply< bind_back< quote< typelist >, Ts... >, List > > push_back
Definition: typelist.h:461
utl::meta::back
eval< back_impl::back_< List > > back
Definition: typelist.h:296
utl::meta::fold_impl::fold_< typelist< Head, Tail... >, V, Fn >::type
eval< fold_< typelist< Tail... >, invoke< Fn, V, Head >, Fn > > type
Definition: typelist.h:361
utl::meta::transform_impl::transform_
Definition: typelist.h:533
utl::meta::pop_front_impl::pop_front_
Definition: typelist.h:486
utl::meta::replace_if_impl::replace_if_
Definition: typelist.h:807
utl::meta::typelist::size
static constexpr size_t size() noexcept
Definition: typelist.h:69
utl::meta::at
at_c< List, N::type::value > at
Definition: typelist.h:253
utl::meta::reverse
eval< reverse_impl::reverse_< List > > reverse
Definition: typelist.h:479
utl::meta::repeat
repeat_c< N::type::value, Ts... > repeat
Definition: typelist.h:161
utl::meta::size_
integral_< size_t, v > size_
size_ type: integral constant wrapper for size_t a.k.a std::size_t
Definition: integral.h:110
utl::meta::cat_impl::cat_
Definition: typelist.h:306
utl::meta::filter_impl::filter_< typelist< Head, Tail... >, Fn, L >::type
if_< invoke_t< Fn, Head >, eval< filter_< typelist< Tail... >, Fn, cat< L, typelist< Head > >> >, eval< filter_< typelist< Tail... >, Fn, L > > > type
Definition: typelist.h:778
utl::meta::typelist::times_
Definition: typelist.h:85
utl::meta::rev_fold_impl::rev_fold_< typelist< Tail >, V, Fn >::type
invoke< Fn, Tail, V > type
Definition: typelist.h:414
utl::meta::replace
eval< replace_if< List, same_as< T >, U > > replace
Definition: typelist.h:848
utl::meta::rev_fold_impl::rev_fold_< typelist< Head, Tail... >, V, Fn >::type
invoke< Fn, Head, eval< rev_fold_< typelist< Tail... >, V, Fn > > > type
Definition: typelist.h:409
utl::meta::find
find_if< List, same_as< T > > find
Definition: typelist.h:663
utl::meta::transform_lazy_impl::transform_lazy_
Definition: typelist.h:575
utl::meta::nil_
Definition: integral.h:43
utl::meta::back_impl::back_
Definition: typelist.h:281
utl::meta::count
count_if< List, same_as< T > > count
Definition: typelist.h:761
utl::meta::rev_fold_impl::rev_fold_
Definition: typelist.h:393
utl::meta::count_if_impl::count_if_< typelist< Head, Tail... >, Fn, N >::type
if_< invoke_t< Fn, Head >, eval< count_if_< typelist< Tail... >, Fn, N+1 > >, eval< count_if_< typelist< Tail... >, Fn, N > > > type
Definition: typelist.h:732
utl::meta::Npos
size_< index_t(-1)> Npos
The last position we can express for indexing.
Definition: integral.h:124
utl::meta::apply_impl::apply_< Fn, typelist< List... > >::type
invoke< Fn, List... > type
Definition: typelist.h:177
utl::meta::seek_if_impl::seek_if_< typelist< Head, Tail... >, Fn, N >::type
if_< invoke_t< Fn, Head >, typelist< Head, Tail... >, eval< seek_if_< typelist< Tail... >, Fn, N+1 > > > type
Definition: typelist.h:681
utl::meta::cat
eval< cat_impl::cat_< Lists... > > cat
Definition: typelist.h:338
utl::meta::find_if_impl::find_if_
Definition: typelist.h:622
utl::meta::typelist::empty
static constexpr bool empty() noexcept
Definition: typelist.h:73
utl::meta::false_
bool_< false > false_
The type used as a compile-time boolean with false value.
Definition: integral.h:69
utl::meta::seek_if
eval< seek_if_impl::seek_if_< List, Pred, 0 > > seek_if
Definition: typelist.h:705
utl::meta::rev_fold
eval< rev_fold_impl::rev_fold_< List, V, Fn > > rev_fold
Definition: typelist.h:438
utl::meta::fold
eval< fold_impl::fold_< List, V, Fn > > fold
Definition: typelist.h:383
utl::meta::eval
typename Tp::type eval
Type alias for Tp::type. Used to evaluate/extract return type of metafunctions.
Definition: integral.h:49
utl::meta::reverse_impl::reverse_::type
fold< List, V, quote< push_front > > type
Definition: typelist.h:468
detection.h
Detection idiom based on WG21&#39;s N4502 [n4502 1] from Walter E. Brown.
utl::meta::any_of
not_< empty< filter< List, Pred > > > any_of
Definition: typelist.h:868
utl
STL&#39;s core language concepts.
Definition: _1wire.h:30
utl::meta::all_of
if_< empty< List >, false_, empty< filter< List, compose< quote< not_ >, Pred > > > > all_of
Definition: typelist.h:861
utl::meta::apply_impl::apply_
Definition: typelist.h:172
utl::meta::back_impl::back_< typelist< Head, Tail... > >::type
at_c< typelist< Head, Tail... >, sizeof...(Tail) > type
Definition: typelist.h:287
utl::meta::typelist::cat_
Definition: typelist.h:78
utl::meta::pop_back
eval< pop_back_impl::pop_back_< List > > pop_back
Definition: typelist.h:526
utl::meta::push_front
eval< apply< bind_front< quote< typelist >, Ts... >, List > > push_front
Definition: typelist.h:450
utl::meta::pop_back_impl::pop_back_
Definition: typelist.h:509
sfinae.h
Template meta-programming SFINAE helpers.
utl::meta::at_impl::at_< typelist< List... >, N >::type
decltype(head_::select(static_cast< add_pointer< List > >(nullptr)...)) type
Definition: typelist.h:233
utl::meta::pop_front
eval< pop_front_impl::pop_front_< List > > pop_front
Definition: typelist.h:502
utl::meta::index_
integral_< index_t, v > index_
index_ type: integral constant wrapper for index_t a.k.a std::size_t
Definition: integral.h:106
utl::meta::front_impl::front_< typelist< Head, Tail... > >::type
Head type
Definition: typelist.h:265
utl::meta::typelist::times
eval< times_< N, Ts... > > times
Definition: typelist.h:117
integral.h
utl::meta::find_if_impl::find_if_< typelist< Head, Tail... >, Fn, N >::type
if_< invoke_t< Fn, Head >, index_< N >, eval< find_if_< typelist< Tail... >, Fn, N+1 > > > type
Definition: typelist.h:633
utl::meta::bool_
integral_< bool, v > bool_
bool_ type: integral constant wrapper for bool
Definition: integral.h:66
utl::index_t
size_t index_t
index_t and size_t mend to be interchangeable
Definition: types.h:38
utl::meta::at_impl::at_
Definition: typelist.h:226
utl::meta::seek_if_impl::seek_if_
Definition: typelist.h:670
utl::meta::at_impl::_add_pointer
Definition: typelist.h:211
utl::meta::front
eval< front_impl::front_< List > > front
Definition: typelist.h:274
utl::meta::filter_impl::filter_
Definition: typelist.h:768
utl::meta::find_if
eval< find_if_impl::find_if_< List, Pred, 0 > > find_if
Definition: typelist.h:657
utl::meta::bind_back
Definition: invoke.h:342
utl::meta::repeat_c
typename typelist< Ts... >::template times< N > repeat_c
Definition: typelist.h:155
utl::meta::rev_fold_impl::rev_fold_< typelist<>, V, Fn >::type
V type
Definition: typelist.h:419
utl::meta::integer_sequence
std::integer_sequence< Tp, Ints... > integer_sequence
Definition: integral.h:129
utl::meta::pop_back_impl::pop_back_::type
reverse< pop_front< reverse< List > > > type
Definition: typelist.h:512
utl::meta::front_impl::front_
Definition: typelist.h:261
utl::meta::transform
eval< transform_impl::transform_< typelist< Args... > > > transform
Definition: typelist.h:568
utl::meta::at_impl::at_head_
Definition: typelist.h:215
utl::meta::count_if_impl::count_if_< typelist<>, Fn, N >::type
size_< N > type
Definition: typelist.h:738
utl::meta::invoke_t
eval< invoke< Fn, Args... > > invoke_t
Definition: invoke.h:88
utl::meta::filter_impl::filter_< typelist<>, Fn, L >::type
L type
Definition: typelist.h:784
utl::meta::typelist
Definition: typelist.h:65
utl::meta::apply_t
eval< apply< Fn, Seq > > apply_t
Definition: typelist.h:200
utl::meta::invoke
typename Fn::template apply< Args... > invoke
Definition: invoke.h:81
utl::meta::not_
not_c< _Tp::type::value > not_
not
Definition: operations.h:47
utl::meta::find_if_impl::find_if_< typelist<>, Fn, N >::type
Npos type
Definition: typelist.h:639
utl::meta::fold_impl::fold_< typelist<>, V0, Fn >::type
V0 type
Definition: typelist.h:366
utl::meta::seek
seek_if< List, same_as< T > > seek
Definition: typelist.h:711
utl::meta::at_impl::_add_pointer::type
T * type
Definition: typelist.h:211
utl::meta::bind_front
Definition: invoke.h:332
utl::meta::empty
bool_< List::empty()> empty
Definition: typelist.h:140
impl.h
Implementation detail main forward header.
utl::meta::replace_if_impl::replace_if_< typelist<>, Fn, T, Ret >::type
Ret type
Definition: typelist.h:823
utl::meta::transform_lazy
eval< transform_lazy_impl::transform_lazy_< typelist< Args... > > > transform_lazy
Definition: typelist.h:614