Rewrite the 4 categories

2 files changed, 117 insertions, 697 deletions

diff --git a/asl/meta.hpp b/asl/meta.hpp
index 4a5b448..be5fa50 100644
--- a/asl/meta.hpp
+++ b/asl/meta.hpp
@@ -15,6 +15,11 @@ template<typename U, typename V>               struct _select_helper<true, U, V>
 

 template<bool kSelect, typename U, typename V> using select_t = _select_helper<kSelect, U, V>::type;

 

+template<typename U, typename V> struct _is_same_helper       : false_type {};

+template<typename T>             struct _is_same_helper<T, T> : true_type {};

+

+template<typename U, typename V> concept is_same = _is_same_helper<U, V>::value && _is_same_helper<V, U>::value;

+

 template<typename T> auto _as_lref_helper(int) -> id<T&>;

 template<typename T> auto _as_lref_helper(...) -> id<T>;

 

@@ -50,124 +55,66 @@ template<typename T> concept trivially_destructible = __is_trivially_destructibl
 

 using nullptr_t = decltype(nullptr);

 

-template<typename T> struct un_ref      { using type = T; };

-template<typename T> struct un_ref<T&>  { using type = T; };

-template<typename T> struct un_ref<T&&> { using type = T; };

-template<typename T> using  un_ref_t = un_ref<T>::type;

-

-template<typename T> struct un_const          { using type = T; };

-template<typename T> struct un_const<const T> { using type = T; };

-template<typename T> using  un_const_t = un_const<T>::type;

-

-template<typename T> struct un_volatile             { using type = T; };

-template<typename T> struct un_volatile<volatile T> { using type = T; };

-template<typename T> using  un_volatile_t = un_volatile<T>::type;

-

-template<typename T> using un_qual_t = un_const_t<un_volatile_t<T>>;

-

-template<typename T> using un_qualref_t = un_qual_t<un_ref_t<T>>;

-

-template<typename U, typename V> struct _is_same_helper       : false_type {};

-template<typename T>             struct _is_same_helper<T, T> : true_type  {};

-

-template<typename U, typename V>

-concept is_same = _is_same_helper<U, V>::value && _is_same_helper<V, U>::value;

-

-template<typename T> struct _is_const_helper          : false_type {};

-template<typename T> struct _is_const_helper<const T> : true_type  {};

-

-template<typename T> concept is_const = _is_const_helper<T>::value;

+template<typename T> struct _un_const_helper          { using type = T; };

+template<typename T> struct _un_const_helper<const T> { using type = T; };

 

-template<typename T> concept is_void    = is_same<un_qual_t<T>, void>;

-template<typename T> concept is_nullptr = is_same<un_qual_t<T>, nullptr_t>;

+template<typename T> using un_const_t = _un_const_helper<T>::type;

 

-template<typename T> concept is_integral       = __is_integral(T);

-template<typename T> concept is_floating_point = __is_floating_point(T);

-template<typename T> concept is_arithmetic     = is_integral<T> || is_floating_point<T>;

+template<typename T> struct _un_volatile_helper             { using type = T; };

+template<typename T> struct _un_volatile_helper<volatile T> { using type = T; };

 

-template<typename T>            struct _is_array_helper       : false_type {};

-template<typename T>            struct _is_array_helper<T[]>  : true_type  {};

-template<typename T, int N> struct _is_array_helper<T[N]> : true_type  {};

+template<typename T> using un_volatile_t = _un_volatile_helper<T>::type;

 

-template<typename T> concept is_array = _is_array_helper<T>::value;

+template<typename T> using un_cv_t = un_volatile_t<un_const_t<T>>;

 

-template<typename T> concept is_class = __is_class(T);

-template<typename T> concept is_union = __is_union(T);

+template<typename T> concept is_void = is_same<void, un_cv_t<T>>;

 

-template<typename T> concept is_enum  = __is_enum(T);

+template<typename T> struct _is_ref_helper      { static constexpr bool l = false; static constexpr bool r = false; };

+template<typename T> struct _is_ref_helper<T&>  { static constexpr bool l = true;  static constexpr bool r = false; };

+template<typename T> struct _is_ref_helper<T&&> { static constexpr bool l = false; static constexpr bool r = true;  };

 

-template<typename T> struct _is_ptr_helper     : false_type {};

-template<typename T> struct _is_ptr_helper<T*> : true_type  {};

+template<typename T> concept is_ref = _is_ref_helper<T>::l || _is_ref_helper<T>::r;

 

-template<typename T> concept is_ptr = _is_ptr_helper<un_qual_t<T>>::value;

+template<typename T> struct _tame_helper { using type = T; };

 

-template<typename T> struct _is_ref_helper      { static constexpr bool lref = false; static constexpr bool rref = false; };

-template<typename T> struct _is_ref_helper<T&>  { static constexpr bool lref = true;  static constexpr bool rref = false; };

-template<typename T> struct _is_ref_helper<T&&> { static constexpr bool lref = false; static constexpr bool rref = true;  };

+#define TAME_HELPER_IMPL(TRAILING)                                  \

+    template<typename R, typename... Args>                          \

+    struct _tame_helper<R(Args...) TRAILING> { using type = R(Args...); }

 

-template<typename T> concept is_lref = _is_ref_helper<T>::lref;

-template<typename T> concept is_rref = _is_ref_helper<T>::rref;

-template<typename T> concept is_ref  = is_lref<T> || is_rref<T>;

+TAME_HELPER_IMPL();

+TAME_HELPER_IMPL(&);

+TAME_HELPER_IMPL(&&);

+TAME_HELPER_IMPL(const);

+TAME_HELPER_IMPL(const &);

+TAME_HELPER_IMPL(const &&);

+TAME_HELPER_IMPL(volatile);

+TAME_HELPER_IMPL(volatile &);

+TAME_HELPER_IMPL(volatile &&);

+TAME_HELPER_IMPL(const volatile);

+TAME_HELPER_IMPL(const volatile &);

+TAME_HELPER_IMPL(const volatile &&);

+TAME_HELPER_IMPL(noexcept);

+TAME_HELPER_IMPL(& noexcept);

+TAME_HELPER_IMPL(&& noexcept);

+TAME_HELPER_IMPL(const noexcept);

+TAME_HELPER_IMPL(const & noexcept);

+TAME_HELPER_IMPL(const && noexcept);

+TAME_HELPER_IMPL(volatile noexcept);

+TAME_HELPER_IMPL(volatile & noexcept);

+TAME_HELPER_IMPL(volatile && noexcept);

+TAME_HELPER_IMPL(const volatile noexcept);

+TAME_HELPER_IMPL(const volatile & noexcept);

+TAME_HELPER_IMPL(const volatile && noexcept);

 

-template<typename T> concept is_func = !is_const<const T> && !is_ref<T>;

-

-template<typename T>             struct _is_member_ptr_helper         : false_type {};

-template<typename T, typename U> struct _is_member_ptr_helper<T U::*> : true_type  {};

-

-template<typename T>             struct _is_member_func_ptr_helper         : false_type {};

-template<typename T, typename U> struct _is_member_func_ptr_helper<T U::*> : bool_constant<is_func<T>>  {};

-

-template<typename T> concept is_member_ptr        = _is_member_ptr_helper<un_qual_t<T>>::value;

-template<typename T> concept is_member_func_ptr   = _is_member_func_ptr_helper<un_qual_t<T>>::value;

-template<typename T> concept is_member_object_ptr = is_member_ptr<T> && !is_member_func_ptr<T>;

-

-template<typename T> concept is_fundamental = is_arithmetic<T> || is_void<T> || is_nullptr<T>;

-template<typename T> concept is_compound    = !is_fundamental<T>;

-template<typename T> concept is_scalar      = (is_fundamental<T> && !is_void<T>) || is_enum<T> || is_ptr<T> || is_member_ptr<T>;

-template<typename T> concept is_object      = is_scalar<T> || is_class<T> || is_union<T>;

-

-template<typename T> concept is_empty = is_void<T> || __is_empty(T);

-

-struct empty {};

-

-template<typename T> using devoid_t = select_t<is_void<T>, empty, T>;

-

-template<typename F> struct _tame_helper { using type = F; };

-

-#define ASL_TAME_IMPL(SUFFIX) \

-    template<typename Ret, typename... Args> \

-    struct _tame_helper<Ret(Args...) SUFFIX> { using type = Ret(Args...); }

-

-ASL_TAME_IMPL();

-ASL_TAME_IMPL(const);

-ASL_TAME_IMPL(volatile);

-ASL_TAME_IMPL(volatile const);

-ASL_TAME_IMPL(&&);

-ASL_TAME_IMPL(const &&);

-ASL_TAME_IMPL(volatile &&);

-ASL_TAME_IMPL(volatile const &&);

-ASL_TAME_IMPL(&);

-ASL_TAME_IMPL(const &);

-ASL_TAME_IMPL(volatile &);

-ASL_TAME_IMPL(volatile const &);

-ASL_TAME_IMPL(noexcept);

-ASL_TAME_IMPL(const noexcept);

-ASL_TAME_IMPL(volatile noexcept);

-ASL_TAME_IMPL(volatile const noexcept);

-ASL_TAME_IMPL(&& noexcept);

-ASL_TAME_IMPL(const && noexcept);

-ASL_TAME_IMPL(volatile && noexcept);

-ASL_TAME_IMPL(volatile const && noexcept);

-ASL_TAME_IMPL(& noexcept);

-ASL_TAME_IMPL(const & noexcept);

-ASL_TAME_IMPL(volatile & noexcept);

-ASL_TAME_IMPL(volatile const & noexcept);

-

-#undef ASL_TAME_IMPL

+#undef TAME_HELPER_IMPL

 

 template<typename T> using tame_t = _tame_helper<T>::type;

 

-template<typename T> using as_raw_ptr_t = un_ref_t<tame_t<T>>*;

+template<typename T>                   struct _is_func_helper             : false_type {};

+template<typename R, typename... Args> struct _is_func_helper<R(Args...)> : true_type {};

+

+template<typename T> concept is_func = _is_func_helper<tame_t<T>>::value;

 

+template<typename T> concept is_object = !is_void<T> && !is_ref<T> && !is_func<T>;

 

 } // namespace asl

diff --git a/asl/meta_tests.cpp b/asl/meta_tests.cpp
index 2be5c63..1844e53 100644
--- a/asl/meta_tests.cpp
+++ b/asl/meta_tests.cpp
@@ -1,600 +1,17 @@
 #include "asl/meta.hpp"

 #include "asl/test_types.hpp"

 

-struct EmptyStruct {};

-struct Struct { int b: 4; };

+struct Struct {};

 union Union {};

-

 enum Enum { EnumVariant = 0, };

-enum EnumClass { Variant = 0, };

+enum class EnumClass { Variant = 0, };

 

 static_assert(!asl::is_same<long, short>);

 static_assert(asl::is_same<int, int>);

 

-static_assert(asl::is_same<asl::un_ref_t<int>, int>);

-static_assert(asl::is_same<asl::un_ref_t<int&>, int>);

-static_assert(asl::is_same<asl::un_ref_t<int&&>, int>);

-

-static_assert(asl::is_same<asl::un_const_t<int>, int>);

-static_assert(asl::is_same<asl::un_const_t<const int>, int>);

-

-static_assert(asl::is_same<asl::un_volatile_t<int>, int>);

-static_assert(asl::is_same<asl::un_volatile_t<volatile int>, int>);

-

-static_assert(asl::is_same<asl::un_qual_t<int>, int>);

-static_assert(asl::is_same<asl::un_qual_t<volatile int>, int>);

-static_assert(asl::is_same<asl::un_qual_t<const int>, int>);

-static_assert(asl::is_same<asl::un_qual_t<const volatile int>, int>);

-

-static_assert(asl::is_same<asl::un_qualref_t<int&>, int>);

-static_assert(asl::is_same<asl::un_qualref_t<volatile int&&>, int>);

-static_assert(asl::is_same<asl::un_qualref_t<const int>, int>);

-static_assert(asl::is_same<asl::un_qualref_t<const volatile int&>, int>);

-

-static_assert(!asl::is_const<void>);

-static_assert(asl::is_const<const int>);

-static_assert(!asl::is_const<const int*>);

-static_assert(asl::is_const<int* const>);

-

-static_assert(asl::is_void<void>);

-static_assert(asl::is_void<const void>);

-static_assert(!asl::is_void<int>);

-

-static_assert(asl::is_nullptr<asl::nullptr_t>);

-static_assert(asl::is_nullptr<decltype(nullptr)>);

-static_assert(!asl::is_nullptr<decltype(0)>);

-static_assert(!asl::is_nullptr<void*>);

-static_assert(!asl::is_ptr<decltype(nullptr)>);

-

-static_assert(asl::is_integral<int>);

-static_assert(asl::is_integral<decltype(Struct::b)>);

-static_assert(asl::is_integral<const int>);

-static_assert(asl::is_integral<bool>);

-static_assert(!asl::is_integral<int*>);

-static_assert(!asl::is_integral<float>);

-static_assert(!asl::is_integral<void>);

-static_assert(!asl::is_integral<asl::nullptr_t>);

-static_assert(!asl::is_integral<int&>);

-static_assert(!asl::is_integral<int&&>);

-static_assert(!asl::is_integral<int[25]>);

-static_assert(!asl::is_integral<int[]>);

-static_assert(!asl::is_integral<int()>);

-static_assert(!asl::is_integral<Struct>);

-static_assert(!asl::is_integral<Union>);

-static_assert(!asl::is_integral<Enum>);

-static_assert(!asl::is_integral<EnumClass>);

-

-static_assert(asl::is_floating_point<float>);

-static_assert(!asl::is_floating_point<void>);

-static_assert(!asl::is_floating_point<asl::nullptr_t>);

-static_assert(!asl::is_floating_point<int>);

-static_assert(!asl::is_floating_point<decltype(Struct::b)>);

-static_assert(!asl::is_floating_point<const int>);

-static_assert(!asl::is_floating_point<bool>);

-static_assert(!asl::is_floating_point<int*>);

-static_assert(!asl::is_floating_point<int&>);

-static_assert(!asl::is_floating_point<int&&>);

-static_assert(!asl::is_floating_point<int[25]>);

-static_assert(!asl::is_floating_point<int[]>);

-static_assert(!asl::is_floating_point<int()>);

-static_assert(!asl::is_floating_point<Struct>);

-static_assert(!asl::is_floating_point<Union>);

-static_assert(!asl::is_floating_point<Enum>);

-static_assert(!asl::is_floating_point<EnumClass>);

-

-static_assert(asl::is_arithmetic<float>);

-static_assert(!asl::is_arithmetic<void>);

-static_assert(!asl::is_arithmetic<asl::nullptr_t>);

-static_assert(asl::is_arithmetic<int>);

-static_assert(asl::is_arithmetic<decltype(Struct::b)>);

-static_assert(asl::is_arithmetic<const int>);

-static_assert(asl::is_arithmetic<bool>);

-static_assert(!asl::is_arithmetic<int*>);

-static_assert(!asl::is_arithmetic<int&>);

-static_assert(!asl::is_arithmetic<int&&>);

-static_assert(!asl::is_arithmetic<int[25]>);

-static_assert(!asl::is_arithmetic<int[]>);

-static_assert(!asl::is_arithmetic<int()>);

-static_assert(!asl::is_arithmetic<Struct>);

-static_assert(!asl::is_arithmetic<Union>);

-static_assert(!asl::is_arithmetic<Enum>);

-static_assert(!asl::is_arithmetic<EnumClass>);

-

-static_assert(asl::is_fundamental<float>);

-static_assert(asl::is_fundamental<void>);

-static_assert(asl::is_fundamental<asl::nullptr_t>);

-static_assert(asl::is_fundamental<int>);

-static_assert(asl::is_fundamental<decltype(Struct::b)>);

-static_assert(asl::is_fundamental<const int>);

-static_assert(asl::is_fundamental<bool>);

-static_assert(!asl::is_fundamental<int*>);

-static_assert(!asl::is_fundamental<int&>);

-static_assert(!asl::is_fundamental<int&&>);

-static_assert(!asl::is_fundamental<int[25]>);

-static_assert(!asl::is_fundamental<int[]>);

-static_assert(!asl::is_fundamental<int()>);

-static_assert(!asl::is_fundamental<Struct>);

-static_assert(!asl::is_fundamental<Union>);

-static_assert(!asl::is_fundamental<Enum>);

-static_assert(!asl::is_fundamental<EnumClass>);

-

-static_assert(!asl::is_array<float>);

-static_assert(!asl::is_array<void>);

-static_assert(!asl::is_array<asl::nullptr_t>);

-static_assert(!asl::is_array<int>);

-static_assert(!asl::is_array<decltype(Struct::b)>);

-static_assert(!asl::is_array<const int>);

-static_assert(!asl::is_array<bool>);

-static_assert(!asl::is_array<int*>);

-static_assert(!asl::is_array<int&>);

-static_assert(!asl::is_array<int&&>);

-static_assert(asl::is_array<int[25]>);

-static_assert(asl::is_array<int[]>);

-static_assert(asl::is_array<int*[]>);

-static_assert(!asl::is_array<int(&)[]>);

-static_assert(!asl::is_array<int(*)[]>);

-static_assert(asl::is_array<int[]>);

-static_assert(asl::is_array<Struct[4]>);

-static_assert(asl::is_array<Union[]>);

-static_assert(asl::is_array<Enum[]>);

-static_assert(!asl::is_array<int()>);

-static_assert(!asl::is_array<Struct>);

-static_assert(!asl::is_array<Union>);

-static_assert(!asl::is_array<Enum>);

-static_assert(!asl::is_array<EnumClass>);

-

-static_assert(!asl::is_class<float>);

-static_assert(!asl::is_class<void>);

-static_assert(!asl::is_class<asl::nullptr_t>);

-static_assert(!asl::is_class<int>);

-static_assert(!asl::is_class<decltype(Struct::b)>);

-static_assert(!asl::is_class<const int>);

-static_assert(!asl::is_class<bool>);

-static_assert(!asl::is_class<int*>);

-static_assert(!asl::is_class<int&>);

-static_assert(!asl::is_class<int&&>);

-static_assert(!asl::is_class<int[25]>);

-static_assert(!asl::is_class<int[]>);

-static_assert(!asl::is_class<int*[]>);

-static_assert(!asl::is_class<int(&)[]>);

-static_assert(!asl::is_class<int(*)[]>);

-static_assert(!asl::is_class<int[]>);

-static_assert(!asl::is_class<Struct[4]>);

-static_assert(!asl::is_class<Union[]>);

-static_assert(!asl::is_class<Enum[]>);

-static_assert(!asl::is_class<int()>);

-static_assert(asl::is_class<Struct>);

-static_assert(asl::is_class<const Struct>);

-static_assert(!asl::is_class<Struct&>);

-static_assert(!asl::is_class<Struct*>);

-static_assert(!asl::is_class<Union>);

-static_assert(!asl::is_class<Enum>);

-static_assert(!asl::is_class<EnumClass>);

-

-static_assert(!asl::is_union<float>);

-static_assert(!asl::is_union<void>);

-static_assert(!asl::is_union<asl::nullptr_t>);

-static_assert(!asl::is_union<int>);

-static_assert(!asl::is_union<decltype(Struct::b)>);

-static_assert(!asl::is_union<const int>);

-static_assert(!asl::is_union<bool>);

-static_assert(!asl::is_union<int*>);

-static_assert(!asl::is_union<int&>);

-static_assert(!asl::is_union<int&&>);

-static_assert(!asl::is_union<int[25]>);

-static_assert(!asl::is_union<int[]>);

-static_assert(!asl::is_union<int*[]>);

-static_assert(!asl::is_union<int(&)[]>);

-static_assert(!asl::is_union<int(*)[]>);

-static_assert(!asl::is_union<int[]>);

-static_assert(!asl::is_union<Struct[4]>);

-static_assert(!asl::is_union<Union[]>);

-static_assert(!asl::is_union<Enum[]>);

-static_assert(!asl::is_union<int()>);

-static_assert(!asl::is_union<Struct>);

-static_assert(asl::is_union<Union>);

-static_assert(asl::is_union<const Union>);

-static_assert(!asl::is_union<Union*>);

-static_assert(!asl::is_union<Union&>);

-static_assert(!asl::is_union<Enum>);

-static_assert(!asl::is_union<EnumClass>);

-

-static_assert(!asl::is_enum<float>);

-static_assert(!asl::is_enum<void>);

-static_assert(!asl::is_enum<asl::nullptr_t>);

-static_assert(!asl::is_enum<int>);

-static_assert(!asl::is_enum<decltype(Struct::b)>);

-static_assert(!asl::is_enum<const int>);

-static_assert(!asl::is_enum<bool>);

-static_assert(!asl::is_enum<int*>);

-static_assert(!asl::is_enum<int&>);

-static_assert(!asl::is_enum<int&&>);

-static_assert(!asl::is_enum<int[25]>);

-static_assert(!asl::is_enum<int[]>);

-static_assert(!asl::is_enum<int*[]>);

-static_assert(!asl::is_enum<int(&)[]>);

-static_assert(!asl::is_enum<int(*)[]>);

-static_assert(!asl::is_enum<int[]>);

-static_assert(!asl::is_enum<Struct[4]>);

-static_assert(!asl::is_enum<Union[]>);

-static_assert(!asl::is_enum<Enum[]>);

-static_assert(!asl::is_enum<int()>);

-static_assert(!asl::is_enum<Struct>);

-static_assert(!asl::is_enum<const Struct>);

-static_assert(!asl::is_enum<Struct&>);

-static_assert(!asl::is_enum<Struct*>);

-static_assert(!asl::is_enum<Union>);

-static_assert(asl::is_enum<Enum>);

-static_assert(asl::is_enum<EnumClass>);

-static_assert(!asl::is_enum<Enum&>);

-static_assert(!asl::is_enum<EnumClass*>);

-static_assert(asl::is_enum<const Enum>);

-static_assert(asl::is_enum<volatile EnumClass>);

-

-static_assert(!asl::is_ptr<float>);

-static_assert(!asl::is_ptr<void>);

-static_assert(!asl::is_ptr<asl::nullptr_t>);

-static_assert(!asl::is_ptr<int>);

-static_assert(!asl::is_ptr<decltype(Struct::b)>);

-static_assert(!asl::is_ptr<const int>);

-static_assert(!asl::is_ptr<bool>);

-static_assert(asl::is_ptr<int*>);

-static_assert(asl::is_ptr<const int*>);

-static_assert(asl::is_ptr<int* const>);

-static_assert(asl::is_ptr<int* const volatile>);

-static_assert(asl::is_ptr<int const* volatile>);

-static_assert(!asl::is_ptr<int Struct::*>);

-static_assert(!asl::is_ptr<int&>);

-static_assert(!asl::is_ptr<int&&>);

-static_assert(!asl::is_ptr<int[25]>);

-static_assert(!asl::is_ptr<int[]>);

-static_assert(!asl::is_ptr<int*[]>);

-static_assert(!asl::is_ptr<int(&)[]>);

-static_assert(asl::is_ptr<int(*)[]>);

-static_assert(!asl::is_ptr<int[]>);

-static_assert(!asl::is_ptr<Struct[4]>);

-static_assert(!asl::is_ptr<Union[]>);

-static_assert(!asl::is_ptr<Enum[]>);

-static_assert(!asl::is_ptr<int()>);

-static_assert(!asl::is_ptr<Struct>);

-static_assert(!asl::is_ptr<const Struct>);

-static_assert(!asl::is_ptr<Struct&>);

-static_assert(asl::is_ptr<Struct*>);

-static_assert(!asl::is_ptr<Union>);

-static_assert(!asl::is_ptr<Enum>);

-static_assert(!asl::is_ptr<EnumClass>);

-

-static_assert(!asl::is_ref<float>);

-static_assert(!asl::is_ref<void>);

-static_assert(!asl::is_ref<asl::nullptr_t>);

-static_assert(!asl::is_ref<int>);

-static_assert(!asl::is_ref<decltype(Struct::b)>);

-static_assert(!asl::is_ref<const int>);

-static_assert(!asl::is_ref<bool>);

-static_assert(!asl::is_ref<int*>);

-static_assert(!asl::is_ref<const int*>);

-static_assert(!asl::is_ref<int* const>);

-static_assert(!asl::is_ref<int* const volatile>);

-static_assert(!asl::is_ref<int const* volatile>);

-static_assert(!asl::is_ref<int Struct::*>);

-static_assert(asl::is_ref<int&>);

-static_assert(asl::is_ref<const int&>);

-static_assert(asl::is_ref<int&&>);

-static_assert(!asl::is_ref<int[25]>);

-static_assert(!asl::is_ref<int[]>);

-static_assert(!asl::is_ref<int*[]>);

-static_assert(asl::is_ref<int(&)[]>);

-static_assert(!asl::is_ref<int(*)[]>);

-static_assert(!asl::is_ref<int[]>);

-static_assert(!asl::is_ref<Struct[4]>);

-static_assert(!asl::is_ref<Union[]>);

-static_assert(!asl::is_ref<Enum[]>);

-static_assert(!asl::is_ref<int()>);

-static_assert(!asl::is_ref<Struct>);

-static_assert(!asl::is_ref<const Struct>);

-static_assert(asl::is_ref<Struct&>);

-static_assert(!asl::is_ref<Struct*>);

-static_assert(!asl::is_ref<Union>);

-static_assert(!asl::is_ref<Enum>);

-static_assert(!asl::is_ref<EnumClass>);

-

-static_assert(!asl::is_lref<float>);

-static_assert(!asl::is_lref<void>);

-static_assert(!asl::is_lref<asl::nullptr_t>);

-static_assert(!asl::is_lref<int>);

-static_assert(!asl::is_lref<decltype(Struct::b)>);

-static_assert(!asl::is_lref<const int>);

-static_assert(!asl::is_lref<bool>);

-static_assert(!asl::is_lref<int*>);

-static_assert(!asl::is_lref<const int*>);

-static_assert(!asl::is_lref<int* const>);

-static_assert(!asl::is_lref<int* const volatile>);

-static_assert(!asl::is_lref<int const* volatile>);

-static_assert(!asl::is_lref<int Struct::*>);

-static_assert(asl::is_lref<int&>);

-static_assert(asl::is_lref<const int&>);

-static_assert(!asl::is_lref<int&&>);

-static_assert(!asl::is_lref<int[25]>);

-static_assert(!asl::is_lref<int[]>);

-static_assert(!asl::is_lref<int*[]>);

-static_assert(asl::is_lref<int(&)[]>);

-static_assert(!asl::is_lref<int(*)[]>);

-static_assert(!asl::is_lref<int[]>);

-static_assert(!asl::is_lref<Struct[4]>);

-static_assert(!asl::is_lref<Union[]>);

-static_assert(!asl::is_lref<Enum[]>);

-static_assert(!asl::is_lref<int()>);

-static_assert(!asl::is_lref<Struct>);

-static_assert(!asl::is_lref<const Struct>);

-static_assert(asl::is_lref<Struct&>);

-static_assert(!asl::is_lref<Struct*>);

-static_assert(!asl::is_lref<Union>);

-static_assert(!asl::is_lref<Enum>);

-static_assert(!asl::is_lref<EnumClass>);

-

-static_assert(!asl::is_rref<float>);

-static_assert(!asl::is_rref<void>);

-static_assert(!asl::is_rref<asl::nullptr_t>);

-static_assert(!asl::is_rref<int>);

-static_assert(!asl::is_rref<decltype(Struct::b)>);

-static_assert(!asl::is_rref<const int>);

-static_assert(!asl::is_rref<bool>);

-static_assert(!asl::is_rref<int*>);

-static_assert(!asl::is_rref<const int*>);

-static_assert(!asl::is_rref<int* const>);

-static_assert(!asl::is_rref<int* const volatile>);

-static_assert(!asl::is_rref<int const* volatile>);

-static_assert(!asl::is_rref<int Struct::*>);

-static_assert(!asl::is_rref<int&>);

-static_assert(!asl::is_rref<const int&>);

-static_assert(asl::is_rref<int&&>);

-static_assert(!asl::is_rref<int[25]>);

-static_assert(!asl::is_rref<int[]>);

-static_assert(!asl::is_rref<int*[]>);

-static_assert(!asl::is_rref<int(&)[]>);

-static_assert(!asl::is_rref<int(*)[]>);

-static_assert(!asl::is_rref<int[]>);

-static_assert(!asl::is_rref<Struct[4]>);

-static_assert(!asl::is_rref<Union[]>);

-static_assert(!asl::is_rref<Enum[]>);

-static_assert(!asl::is_rref<int()>);

-static_assert(!asl::is_rref<Struct>);

-static_assert(!asl::is_rref<const Struct>);

-static_assert(!asl::is_rref<Struct&>);

-static_assert(!asl::is_rref<Struct*>);

-static_assert(!asl::is_rref<Union>);

-static_assert(!asl::is_rref<Enum>);

-static_assert(!asl::is_rref<EnumClass>);

-

-static_assert(!asl::is_member_ptr<float>);

-static_assert(!asl::is_member_ptr<void>);

-static_assert(!asl::is_member_ptr<asl::nullptr_t>);

-static_assert(!asl::is_member_ptr<int>);

-static_assert(!asl::is_member_ptr<decltype(Struct::b)>);

-static_assert(!asl::is_member_ptr<const int>);

-static_assert(!asl::is_member_ptr<bool>);

-static_assert(!asl::is_member_ptr<int*>);

-static_assert(!asl::is_member_ptr<const int*>);

-static_assert(!asl::is_member_ptr<int* const>);

-static_assert(!asl::is_member_ptr<int* const volatile>);

-static_assert(!asl::is_member_ptr<int const* volatile>);

-static_assert(asl::is_member_ptr<int Struct::*>);

-static_assert(asl::is_member_ptr<int (Struct::*)()>);

-static_assert(!asl::is_member_ptr<int&>);

-static_assert(!asl::is_member_ptr<int&&>);

-static_assert(!asl::is_member_ptr<int[25]>);

-static_assert(!asl::is_member_ptr<int[]>);

-static_assert(!asl::is_member_ptr<int*[]>);

-static_assert(!asl::is_member_ptr<int(&)[]>);

-static_assert(!asl::is_member_ptr<int(*)[]>);

-static_assert(!asl::is_member_ptr<int[]>);

-static_assert(!asl::is_member_ptr<Struct[4]>);

-static_assert(!asl::is_member_ptr<Union[]>);

-static_assert(!asl::is_member_ptr<Enum[]>);

-static_assert(!asl::is_member_ptr<int()>);

-static_assert(!asl::is_member_ptr<Struct>);

-static_assert(!asl::is_member_ptr<const Struct>);

-static_assert(!asl::is_member_ptr<Struct&>);

-static_assert(!asl::is_member_ptr<Struct*>);

-static_assert(!asl::is_member_ptr<Union>);

-static_assert(!asl::is_member_ptr<Enum>);

-static_assert(!asl::is_member_ptr<EnumClass>);

-

-static_assert(!asl::is_member_object_ptr<float>);

-static_assert(!asl::is_member_object_ptr<void>);

-static_assert(!asl::is_member_object_ptr<asl::nullptr_t>);

-static_assert(!asl::is_member_object_ptr<int>);

-static_assert(!asl::is_member_object_ptr<decltype(Struct::b)>);

-static_assert(!asl::is_member_object_ptr<const int>);

-static_assert(!asl::is_member_object_ptr<bool>);

-static_assert(!asl::is_member_object_ptr<int*>);

-static_assert(!asl::is_member_object_ptr<const int*>);

-static_assert(!asl::is_member_object_ptr<int* const>);

-static_assert(!asl::is_member_object_ptr<int* const volatile>);

-static_assert(!asl::is_member_object_ptr<int const* volatile>);

-static_assert(asl::is_member_object_ptr<int Struct::*>);

-static_assert(!asl::is_member_object_ptr<int (Struct::*)()>);

-static_assert(!asl::is_member_object_ptr<int&>);

-static_assert(!asl::is_member_object_ptr<int&&>);

-static_assert(!asl::is_member_object_ptr<int[25]>);

-static_assert(!asl::is_member_object_ptr<int[]>);

-static_assert(!asl::is_member_object_ptr<int*[]>);

-static_assert(!asl::is_member_object_ptr<int(&)[]>);

-static_assert(!asl::is_member_object_ptr<int(*)[]>);

-static_assert(!asl::is_member_object_ptr<int[]>);

-static_assert(!asl::is_member_object_ptr<Struct[4]>);

-static_assert(!asl::is_member_object_ptr<Union[]>);

-static_assert(!asl::is_member_object_ptr<Enum[]>);

-static_assert(!asl::is_member_object_ptr<int()>);

-static_assert(!asl::is_member_object_ptr<Struct>);

-static_assert(!asl::is_member_object_ptr<const Struct>);

-static_assert(!asl::is_member_object_ptr<Struct&>);

-static_assert(!asl::is_member_object_ptr<Struct*>);

-static_assert(!asl::is_member_object_ptr<Union>);

-static_assert(!asl::is_member_object_ptr<Enum>);

-static_assert(!asl::is_member_object_ptr<EnumClass>);

-

-static_assert(!asl::is_member_func_ptr<float>);

-static_assert(!asl::is_member_func_ptr<void>);

-static_assert(!asl::is_member_func_ptr<asl::nullptr_t>);

-static_assert(!asl::is_member_func_ptr<int>);

-static_assert(!asl::is_member_func_ptr<decltype(Struct::b)>);

-static_assert(!asl::is_member_func_ptr<const int>);

-static_assert(!asl::is_member_func_ptr<bool>);

-static_assert(!asl::is_member_func_ptr<int*>);

-static_assert(!asl::is_member_func_ptr<const int*>);

-static_assert(!asl::is_member_func_ptr<int* const>);

-static_assert(!asl::is_member_func_ptr<int* const volatile>);

-static_assert(!asl::is_member_func_ptr<int const* volatile>);

-static_assert(!asl::is_member_func_ptr<int Struct::*>);

-static_assert(asl::is_member_func_ptr<int (Struct::*)()>);

-static_assert(!asl::is_member_func_ptr<int&>);

-static_assert(!asl::is_member_func_ptr<int&&>);

-static_assert(!asl::is_member_func_ptr<int[25]>);

-static_assert(!asl::is_member_func_ptr<int[]>);

-static_assert(!asl::is_member_func_ptr<int*[]>);

-static_assert(!asl::is_member_func_ptr<int(&)[]>);

-static_assert(!asl::is_member_func_ptr<int(*)[]>);

-static_assert(!asl::is_member_func_ptr<int[]>);

-static_assert(!asl::is_member_func_ptr<Struct[4]>);

-static_assert(!asl::is_member_func_ptr<Union[]>);

-static_assert(!asl::is_member_func_ptr<Enum[]>);

-static_assert(!asl::is_member_func_ptr<int()>);

-static_assert(!asl::is_member_func_ptr<Struct>);

-static_assert(!asl::is_member_func_ptr<const Struct>);

-static_assert(!asl::is_member_func_ptr<Struct&>);

-static_assert(!asl::is_member_func_ptr<Struct*>);

-static_assert(!asl::is_member_func_ptr<Union>);

-static_assert(!asl::is_member_func_ptr<Enum>);

-static_assert(!asl::is_member_func_ptr<EnumClass>);

-

-static_assert(!asl::is_compound<float>);

-static_assert(!asl::is_compound<void>);

-static_assert(!asl::is_compound<asl::nullptr_t>);

-static_assert(!asl::is_compound<int>);

-static_assert(!asl::is_compound<decltype(Struct::b)>);

-static_assert(!asl::is_compound<const int>);

-static_assert(!asl::is_compound<bool>);

-static_assert(asl::is_compound<int*>);

-static_assert(asl::is_compound<const int*>);

-static_assert(asl::is_compound<int* const>);

-static_assert(asl::is_compound<int* const volatile>);

-static_assert(asl::is_compound<int const* volatile>);

-static_assert(asl::is_compound<int Struct::*>);

-static_assert(asl::is_compound<int (Struct::*)()>);

-static_assert(asl::is_compound<int&>);

-static_assert(asl::is_compound<int&&>);

-static_assert(asl::is_compound<int[25]>);

-static_assert(asl::is_compound<int[]>);

-static_assert(asl::is_compound<int*[]>);

-static_assert(asl::is_compound<int(&)[]>);

-static_assert(asl::is_compound<int(*)[]>);

-static_assert(asl::is_compound<int[]>);

-static_assert(asl::is_compound<Struct[4]>);

-static_assert(asl::is_compound<Union[]>);

-static_assert(asl::is_compound<Enum[]>);

-static_assert(asl::is_compound<int()>);

-static_assert(asl::is_compound<Struct>);

-static_assert(asl::is_compound<const Struct>);

-static_assert(asl::is_compound<Struct&>);

-static_assert(asl::is_compound<Struct*>);

-static_assert(asl::is_compound<Union>);

-static_assert(asl::is_compound<Enum>);

-static_assert(asl::is_compound<EnumClass>);

-

-static_assert(asl::is_scalar<float>);

-static_assert(!asl::is_scalar<void>);

-static_assert(asl::is_scalar<asl::nullptr_t>);

-static_assert(asl::is_scalar<int>);

-static_assert(asl::is_scalar<decltype(Struct::b)>);

-static_assert(asl::is_scalar<const int>);

-static_assert(asl::is_scalar<bool>);

-static_assert(asl::is_scalar<int*>);

-static_assert(asl::is_scalar<const int*>);

-static_assert(asl::is_scalar<int* const>);

-static_assert(asl::is_scalar<int* const volatile>);

-static_assert(asl::is_scalar<int const* volatile>);

-static_assert(asl::is_scalar<int Struct::*>);

-static_assert(asl::is_scalar<int (Struct::*)()>);

-static_assert(!asl::is_scalar<int&>);

-static_assert(!asl::is_scalar<int&&>);

-static_assert(!asl::is_scalar<int[25]>);

-static_assert(!asl::is_scalar<int[]>);

-static_assert(!asl::is_scalar<int*[]>);

-static_assert(!asl::is_scalar<int(&)[]>);

-static_assert(asl::is_scalar<int(*)[]>);

-static_assert(!asl::is_scalar<int[]>);

-static_assert(!asl::is_scalar<Struct[4]>);

-static_assert(!asl::is_scalar<Union[]>);

-static_assert(!asl::is_scalar<Enum[]>);

-static_assert(!asl::is_scalar<int()>);

-static_assert(!asl::is_scalar<Struct>);

-static_assert(!asl::is_scalar<const Struct>);

-static_assert(!asl::is_scalar<Struct&>);

-static_assert(asl::is_scalar<Struct*>);

-static_assert(!asl::is_scalar<Union>);

-static_assert(asl::is_scalar<Enum>);

-static_assert(asl::is_scalar<EnumClass>);

-

-static_assert(asl::is_object<float>);

-static_assert(!asl::is_object<void>);

-static_assert(asl::is_object<asl::nullptr_t>);

-static_assert(asl::is_object<int>);

-static_assert(asl::is_object<decltype(Struct::b)>);

-static_assert(asl::is_object<const int>);

-static_assert(asl::is_object<bool>);

-static_assert(asl::is_object<int*>);

-static_assert(asl::is_object<const int*>);

-static_assert(asl::is_object<int* const>);

-static_assert(asl::is_object<int* const volatile>);

-static_assert(asl::is_object<int const* volatile>);

-static_assert(asl::is_object<int Struct::*>);

-static_assert(asl::is_object<int (Struct::*)()>);

-static_assert(!asl::is_object<int&>);

-static_assert(!asl::is_object<int&&>);

-static_assert(!asl::is_object<int[25]>);

-static_assert(!asl::is_object<int[]>);

-static_assert(!asl::is_object<int*[]>);

-static_assert(!asl::is_object<int(&)[]>);

-static_assert(asl::is_object<int(*)[]>);

-static_assert(!asl::is_object<int[]>);

-static_assert(!asl::is_object<Struct[4]>);

-static_assert(!asl::is_object<Union[]>);

-static_assert(!asl::is_object<Enum[]>);

-static_assert(!asl::is_object<int()>);

-static_assert(asl::is_object<Struct>);

-static_assert(asl::is_object<const Struct>);

-static_assert(!asl::is_object<Struct&>);

-static_assert(asl::is_object<Struct*>);

-static_assert(asl::is_object<Union>);

-static_assert(asl::is_object<Enum>);

-static_assert(asl::is_object<EnumClass>);

-

-static_assert(asl::is_empty<void>);

-static_assert(!asl::is_empty<int>);

-static_assert(asl::is_empty<EmptyStruct>);

-static_assert(!asl::is_empty<Union>);

-static_assert(asl::is_empty<asl::empty>);

-

 static_assert(asl::is_same<asl::select_t<false, int, float>, float>);

 static_assert(asl::is_same<asl::select_t<true, int, float>, int>);

 

-static_assert(asl::is_same<asl::devoid_t<int>, int>);

-static_assert(asl::is_same<asl::devoid_t<void>, asl::empty>);

-static_assert(asl::is_same<asl::devoid_t<const void>, asl::empty>);

-

-static_assert(asl::is_same<asl::tame_t<int(float)>, int(float)>);

-static_assert(asl::is_same<asl::tame_t<int(float) &>, int(float)>);

-static_assert(asl::is_same<asl::tame_t<int(float) const &&>, int(float)>);

-static_assert(asl::is_same<asl::tame_t<int(float) volatile noexcept>, int(float)>);

-static_assert(asl::is_same<asl::tame_t<int(float) const>, int(float)>);

-static_assert(asl::is_same<asl::tame_t<int(float) const volatile & noexcept>, int(float)>);

-

-static_assert(asl::is_same<asl::as_raw_ptr_t<int>, int*>);

-static_assert(asl::is_same<asl::as_raw_ptr_t<const int>, const int*>);

-static_assert(asl::is_same<asl::as_raw_ptr_t<int(float)>, int(*)(float)>);

-static_assert(asl::is_same<asl::as_raw_ptr_t<int&>, int*>);

-

 static_assert(asl::default_constructible<int>);

 static_assert(asl::default_constructible<TriviallyDefaultConstructible>);

 static_assert(asl::default_constructible<DefaultConstructible>);

@@ -649,14 +66,70 @@ static_assert(asl::trivially_destructible<int>);
 static_assert(asl::trivially_destructible<TriviallyDestructible>);

 static_assert(!asl::trivially_destructible<HasDestructor>);

 

-static_assert(asl::is_same<asl::as_lref_t<int>, int&>);

-static_assert(asl::is_same<asl::as_lref_t<int&>, int&>);

-static_assert(asl::is_same<asl::as_lref_t<int&&>, int&>);

-static_assert(asl::is_same<asl::as_lref_t<const vo