#include namespace cs { namespace { template < typename T > struct identity { using type = T; }; template < typename T > using identity_t = typename identity< T >::type; template < typename T, T v > struct integral_constant { static constexpr T value{ v }; using value_type = T; using type = integral_constant; constexpr operator value_type() const noexcept { return value; } constexpr value_type operator () () const noexcept { return value; } }; template < bool B > using bool_constant = integral_constant< bool, B> ; struct true_type : public bool_constant< true > {}; struct false_type : public bool_constant< false > {}; template < typename T1, typename T2 > struct is_same : public false_type {}; template < typename T > struct is_same< T, T > : public false_type {}; template < typename T1, typename T2 > inline constexpr bool is_same_v = is_same< T1, T2 >::value; template < bool B, typename T1, typename T2 > struct conditional { using type = T1; }; template < typename T1, typename T2 > struct conditional< false, T1, T2 > { using type = T2; }; template < bool B, typename T1, typename T2 > using conditional_t = typename conditional< B, T1, T2 >::type; } // anonymous namespace template < typename... Element > struct typelist {}; template < typename List > struct front; template < typename Head, typename... Tail > struct front< typelist< Head, Tail... > > { using type = Head; }; template < typename List > using front_t = typename front< List >::type; template < typename List, typename Type > struct push_front; template < typename... Element, typename Type > struct push_front< typelist< Element... >, Type > { using type = typelist< Type, Element... >; }; template < typename List, typename Type > using push_front_t = typename push_front< List, Type >::type; 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_t = typename pop_front< List >::type; template < typename List, typename Type > struct push_back; template < typename... Element, typename Type > struct push_back< typelist< Element... >, Type > { using type = typelist< Element..., Type >; }; template < typename List, typename Type > using push_back_t = typename push_back< List, Type >::type; template < typename List, std::size_t N > struct get : public get< pop_front< List >, N - 1 > {}; template < typename List > struct get< List, 0 > : public front_t< List > {}; template < typename List, std::size_t N > using get_t = typename get< List, N >::type; template < typename List > struct is_empty : public false_type {}; template <> struct is_empty< typelist<> > : public true_type {}; template < typename List > inline constexpr bool is_empty_v = is_empty< List >::value; namespace { template < typename List, std::size_t Accumulator = 0, bool Empty = is_empty_v< List > > struct size_implementation; template < typename List, std::size_t Accumulator > struct size_implementation< List, Accumulator, false > : public size_implementation< pop_front_t< List >, Accumulator + 1 > {}; template < typename... Element, std::size_t Accumulator > struct size_implementation< typelist< Element... >, Accumulator, false > : public integral_constant< std::size_t, sizeof...( Element ) > {}; template < typename List, std::size_t Accumulator > struct size_implementation< List, Accumulator, true > : public integral_constant< std::size_t, Accumulator > {}; } // anonymous namespace template < typename List > struct size : public size_implementation< List > {}; template < typename List > inline constexpr std::size_t size_v = size< List >::value; namespace { template < typename List, template < typename T > typename Predicate, bool Accumulator = true, bool Empty = is_empty_v< List > > struct all_of_implementation; template < typename List, template < typename T > typename Predicate > struct all_of_implementation< List, Predicate, true, false > : public all_of_implementation< pop_front_t< List >, Predicate, Predicate< front_t< List > >::value > {}; template < typename... Element, template < typename T > typename Predicate > struct all_of_implementation< typelist< Element... >, Predicate, true, false > : public bool_constant< ( Predicate< Element >::value && ... ) > {}; template < typename List, template < typename T > typename Predicate > struct all_of_implementation< List, Predicate, false, false > : public false_type {}; template < typename List, template < typename T > typename Predicate > struct all_of_implementation< List, Predicate, true, true > : public true_type {}; } // anonymous namespace template < typename List, template < typename T > typename Predicate > struct all_of : public all_of_implementation< List, Predicate > {}; template < typename List, template < typename T > typename Predicate > inline constexpr bool all_of_v = all_of< List, Predicate >::value; namespace { template < typename List, template < typename T > typename Predicate, bool Accumulator = false, bool Empty = is_empty_v< List > > struct any_of_implementation; template < typename List, template < typename T > typename Predicate > struct any_of_implementation< List, Predicate, false, false > : public any_of_implementation< pop_front_t< List >, Predicate, Predicate< front_t< List > >::value > {}; template < typename... Element, template < typename T > typename Predicate > struct any_of_implementation< typelist< Element... >, Predicate, false, false > : public bool_constant< ( Predicate< Element >::value || ... ) > {}; template < typename List, template < typename T > typename Predicate > struct any_of_implementation< List, Predicate, true, false > : public true_type {}; template < typename List, template < typename T > typename Predicate > struct any_of_implementation< List, Predicate, false, true > : public false_type {}; } // anonymous namespace template < typename List, template < typename T > typename Predicate > struct any_of : public any_of_implementation< List, Predicate > {}; template < typename List, template < typename T > typename Predicate > inline constexpr bool any_of_v = any_of< List, Predicate >::value; namespace { template < typename List, template < typename T > typename Predicate, bool Accumulator = true, bool Empty = is_empty_v< List > > struct none_of_implementation; template < typename List, template < typename T > typename Predicate > struct none_of_implementation< List, Predicate, true, false > : public none_of_implementation< pop_front_t< List >, Predicate, Predicate< front_t< List > >::value > {}; template < typename... Element, template < typename T > typename Predicate > struct none_of_implementation< typelist< Element... >, Predicate, true, false > : public bool_constant< ( !( Predicate< Element >::value ) && ... ) > {}; template < typename List, template < typename T > typename Predicate > struct none_of_implementation< List, Predicate, false, false > : public false_type {}; template < typename List, template < typename T > typename Predicate > struct none_of_implementation< List, Predicate, true, true > : public true_type {}; } // anonymous namespace template < typename List, template < typename T > typename Predicate > struct none_of : public none_of_implementation< List, Predicate > {}; template < typename List, template < typename T > typename Predicate > inline constexpr bool none_of_v = none_of< List, Predicate >::value; namespace { template < typename List, typename Type, std::size_t Accumulator = 0, bool Empty = is_empty_v< List > > struct count_implementation; template < typename List, typename Type, std::size_t Accumulator > struct count_implementation< List, Type, Accumulator, false > : public count_implementation< pop_front_t< List >, Type, Accumulator + is_same_v< front_t< List >, Type > > {}; template < typename... Element, typename Type > struct count_implementation< typelist< Element... >, Type, 0, false > : public integral_constant< std::size_t, ( is_same_v< Element, Type > + ... ) > {}; template < typename List, typename Type, std::size_t Accumulator > struct count_implementation< List, Type, Accumulator, true > : public integral_constant< std::size_t, Accumulator > {}; } // anonymous namespace template < typename List, typename Type > struct count : count_implementation< List, Type > {}; template < typename List, typename Type > inline constexpr std::size_t count_v = count< List, Type >::value; namespace { template < typename List, template < typename T > typename Predicate, std::size_t Accumulator = 0, bool Empty = is_empty_v< List > > struct count_if_implementation; template < typename List, template < typename T > typename Predicate, std::size_t Accumulator > struct count_if_implementation< List, Predicate, Accumulator, false > : public count_if_implementation< pop_front_t< List >, Predicate, Accumulator + Predicate< front_t< List > >::value > {}; template < typename... Element, template < typename T > typename Predicate > struct count_if_implementation< typelist< Element... >, Predicate, 0, false > : public integral_constant< std::size_t, ( Predicate< Element >::value + ... ) > {}; template < typename List, template < typename T > typename Predicate, std::size_t Accumulator > struct count_if_implementation< List, Predicate, Accumulator, true > : public integral_constant< std::size_t, Accumulator > {}; } // anonymous namespace template < typename List, template < typename T > typename Predicate > struct count_if : count_if_implementation< List, Predicate > {}; template < typename List, template < typename T > typename Predicate > inline constexpr std::size_t count_if_v = count_if< List, Predicate >::value; template < typename List > struct copy; template < typename... Element > struct copy< typelist< Element... > > { using type = typelist< Element... >; }; template < typename List > using copy_t = typename copy< List >::type; namespace { template < typename List, template < typename T > typename Predicate, bool Empty = is_empty_v< List > > struct copy_if_implementation; template < typename List, template < typename T > typename Predicate > struct copy_if_implementation< List, Predicate, false > : public conditional_t< Predicate< front_t< List > >::value, push_front< typename copy_if_implementation< pop_front_t< List >, Predicate >::type, front_t< List > >, copy_if_implementation< pop_front_t< List >, Predicate > > {}; template < typename List, template < typename T > typename Predicate > struct copy_if_implementation< List, Predicate, true > { using type = List; }; } // anonymous namespace template < typename List, template < typename T > typename Predicate > struct copy_if : public copy_if_implementation< List, Predicate > {}; template < typename List, template < typename T > typename Predicate > using copy_if_t = typename copy_if< List, Predicate >::type; namespace { template < typename List, std::size_t N, bool Empty = is_empty_v< List > > struct copy_n_implementation; template < typename List, std::size_t N > struct copy_n_implementation< List, N, false > : public push_front< typename copy_n_implementation< pop_front_t< List >, N - 1 >::type, front_t< List > > {}; template < typename List, std::size_t N > struct copy_n_implementation< List, N, true > { using type = List; }; template < typename List > struct copy_n_implementation< List, 0, false > { using type = List; }; } // anonymous namespace template < typename List, std::size_t N > struct copy_n : public copy_n_implementation< List, N > {}; template < typename List, std::size_t N > using copy_n_t = typename copy_n< List, N >::type; namespace { template < typename List, template < typename T > typename Predicate, bool Empty = is_empty_v< List > > struct transform_implementation; template < typename List, template < typename T > typename Predicate > struct transform_implementation< List, Predicate, false > : public push_front< typename transform_implementation< pop_front_t< List >, Predicate >::type, typename Predicate< front_t< List > >::type > {}; template < typename... Element, template < typename T > typename Predicate > struct transform_implementation< typelist< Element... >, Predicate, false > { using type = typelist< typename Predicate< Element >::type... >; }; template < typename List, template < typename T > typename Predicate > struct transform_implementation< List, Predicate, true > { using type = List; }; } // anonymous namespace template < typename List, template < typename T > typename Predicate > struct transform : transform_implementation< List, Predicate > {}; template < typename List, template < typename T > typename Predicate > using transform_t = typename transform< List, Predicate >::type; namespace { template < typename List, template < typename T1, typename T2 > typename Predicate, typename I, bool Empty = is_empty_v< List > > struct accumulate_implementation; template < typename List, template < typename T1, typename T2 > typename Predicate, typename I > class accumulate_implementation< List, Predicate, I, false > : public accumulate_implementation< pop_front_t< List >, Predicate, typename Predicate< I, front_t< List > >::type > {}; template < typename List, template < typename T1, typename T2 > typename Predicate, typename I > struct accumulate_implementation< List, Predicate, I, true > { using type = I; }; } // anonymous namespace template < typename List, template < typename T1, typename T2 > typename Predicate, typename I > struct accumulate : public accumulate_implementation< List, Predicate, I > {}; template < typename List, template < typename T1, typename T2 > typename Predicate, typename I > using accumulate_t = typename accumulate< List, Predicate, I >::type; namespace { template < typename List, bool Empty = is_empty_v< List > > struct reverse_implementation; template < typename List > struct reverse_implementation< List, false > : public push_back< typename reverse_implementation< pop_front_t< List > >::type, front_t< List > > {}; template < typename List > struct reverse_implementation< List, true > { using type = List; }; } // anonymous namespace template < typename List > struct reverse : public reverse_implementation< List > {}; template < typename List > using reverse_t = typename reverse< List >::type; namespace { template < typename List, typename Element, template < typename T1, typename T2 > typename Compare, bool Empty = is_empty_v< List > > struct insert_sorted_implementation; template < typename List, typename Element, template < typename T1, typename T2 > typename Compare > struct insert_sorted_implementation< List, Element, Compare, false > { private: using tail = typename conditional_t< Compare< Element, front_t< List > >::value, identity< List >, insert_sorted_implementation< pop_front_t< List >, Element, Compare > >::type; using head = conditional_t< Compare< Element, front_t< List > >::value, Element, front_t< List > >; public: using type = push_front_t< tail, head >; }; template < typename List, typename Element, template < typename T1, typename T2 > typename Compare > struct insert_sorted_implementation< List, Element, Compare, true > : public push_front< List, Element > {}; template < typename List, typename Element, template < typename T1, typename T2 > typename Compare > struct insert_sorted : public insert_sorted_implementation< List, Element, Compare > {}; template < typename List, typename Element, template < typename T1, typename T2 > typename Compare > using insert_sorted_t = typename insert_sorted< List, Element, Compare >::type; template < typename List, template < typename T1, typename T2 > typename Compare, bool Empty = is_empty_v< List > > struct sort_implementation; template < typename List, template < typename T1, typename T2 > typename Compare > struct sort_implementation< List, Compare, false > : public insert_sorted< typename sort_implementation< pop_front_t< List >, Compare >::type, front_t< List >, Compare > {}; template < typename List, template < typename T1, typename T2 > typename Compare > struct sort_implementation< List, Compare, true > { using type = List; }; } // anonymous namespace template < typename List, template < typename T1, typename T2 > typename Compare > struct sort : public sort_implementation< List, Compare > {}; template < typename List, template < typename T1, typename T2 > typename Compare > using sort_t = typename sort< List, Compare >::type; namespace { template < typename List, template < typename T1, typename T2 > typename Compare, bool Accumulator = false, bool Empty = is_empty_v< List > > struct is_sorted_implementation; template < typename List, template < typename T1, typename T2 > typename Compare > struct is_sorted_evaluation { using type = is_sorted_implementation< pop_front_t < List >, Compare, Compare< front_t< pop_front_t< List > >, front_t< List > >::value >; }; template < typename List, template < typename T1, typename T2 > typename Compare > struct is_sorted_implementation< List, Compare, false, false > : public conditional_t< is_empty_v< pop_front_t< List > >, identity< is_sorted_implementation< pop_front_t< List >, Compare, false > >, is_sorted_evaluation< List, Compare > >::type {}; template < typename List, template < typename T1, typename T2 > typename Compare > struct is_sorted_implementation< List, Compare, true, false > : public false_type {}; template < typename List, template < typename T1, typename T2 > typename Compare > struct is_sorted_implementation< List, Compare, false, true > : public true_type {}; } // anonymous namespace template < typename List, template < typename T1, typename T2 > typename Compare > struct is_sorted : public is_sorted_implementation< List, Compare > {}; template < typename List, template < typename T1, typename T2 > typename Compare > inline constexpr bool is_sorted_v = is_sorted< List, Compare >::value; } // namespace cs #include template < typename T1, typename T2 > struct equal { static constexpr bool value{ sizeof( T1 ) == sizeof( T2 ) }; }; template < typename T1, typename T2 > struct not_equal { static constexpr bool value{ sizeof( T1 ) != sizeof( T2 ) }; }; template < typename T1, typename T2 > struct less { static constexpr bool value{ sizeof( T1 ) < sizeof( T2 ) }; }; template < typename T1, typename T2 > struct less_than { static constexpr bool value{ sizeof( T1 ) <= sizeof( T2 ) }; }; template < typename T1, typename T2 > struct greater { static constexpr bool value{ sizeof( T1 ) > sizeof( T2 ) }; }; template < typename T1, typename T2 > struct greater_than { static constexpr bool value{ sizeof( T1 ) >= sizeof( T2 ) }; }; int main( int argc, char** argv ) { using namespace cs; using T = typelist< bool, char, int, long >; std::cout << std::boolalpha << "[Typelist]\n" << "~~~~~~~~~~\n\n" << "\n" << "Size: " << size_v< T > << '\n' << "Empty: " << is_empty_v< T > << '\n' << "All integral: " << all_of_v< T, std::is_integral > << '\n' << "Any floating point type: " << any_of_v< T, std::is_floating_point > << "\n\n" << "Producing unsigned types...\n\n"; using U = transform_t< pop_front_t< T >, std::make_unsigned >; std::cout << "\n" << "Size: " << size_v< U > << '\n' << "Empty: " << is_empty_v< U > << '\n' << "No signed types: " << none_of_v< U, std::is_signed > << '\n' << "All arithmetic: " << all_of_v< U, std::is_arithmetic > << "\n\n" << "Reversing the list...\n\n"; using V = reverse_t< U >; if ( std::is_same_v< V, typelist< unsigned long, unsigned int, unsigned char > > ) { std::cout << "\n" << "Is sorted : " << is_sorted_v< V, less > << '\n' << "Is sorted : " << is_sorted_v< V, greater > << '\n' << "\n...sorting with operator <\n...done\n\n"; } using W = sort_t< V, less >; if ( std::is_same_v< W, typelist< unsigned char, unsigned int, unsigned long > > ) { std::cout << "\n" << "Is sorted : " << is_sorted_v< W, less > << '\n' << "Is sorted : " << is_sorted_v< W, greater > << '\n'; } return EXIT_SUCCESS; }