diff --git a/Concepts.h b/Concepts.h
index 0f36a96..2804055 100644
--- a/Concepts.h
+++ b/Concepts.h
@@ -56,6 +56,8 @@ namespace Alepha::Hydrogen  ::detail::  core_concepts
 			and ConvertibleTo< T, Target >
 		;
 
+		template< typename T >
+		concept EmptyType= std::is_empty_v< T >;
 
 		// Stream related concepts...
 		template< typename T >
diff --git a/Reflection/aggregate_members.h b/Reflection/aggregate_members.h
index c62471f..b44bac3 100644
--- a/Reflection/aggregate_members.h
+++ b/Reflection/aggregate_members.h
@@ -8,6 +8,8 @@ static_assert( __cplusplus > 2020'00 );
 #include <utility>
 #include <type_traits>
 
+#include <Alepha/Concepts.h>
+
 #include <Alepha/Reflection/detail/config.h>
 #include <Alepha/Reflection/aggregate_initialization.h>
 
@@ -82,15 +84,15 @@ namespace Alepha::Hydrogen::Reflection
 		template< typename Aggregate >
 		struct empty_base
 		{
-			template
-			<
-				typename T,
+			template< typename T >
+			requires
+			(
+				true
 				//typename= typename checker< std::decay_t< T > >::type,
-				typename= std::enable_if_t< std::is_empty_v< std::decay_t< T > > >,
-				typename= std::enable_if_t< not std::is_same_v< std::decay_t< T >, Aggregate > >,
-				typename= std::enable_if_t< std::is_base_of_v< std::decay_t< T >, Aggregate > >,
-				overload< __LINE__ > = nullptr
-			>
+				and EmptyType< std::decay_t< T > >
+				and not SameAs< std::decay_t< T >, Aggregate >
+				and DerivedFrom< Aggregate, std::decay_t< T > >
+			)
 			constexpr operator T ();
 
 			//template< typename T > constexpr operator T ()= delete;
@@ -130,22 +132,16 @@ namespace Alepha::Hydrogen::Reflection
 			}
 		}
 
-		template< typename T, typename Tuple, typename= void >
-		struct is_constructible_from_tuple : std::false_type {};
+		template< typename T, typename Tuple >
+		constexpr bool is_constructible_from_tuple_v= false;
 
 		template< typename T, typename ... TupleArgs >
-		struct is_constructible_from_tuple
-		<
-			T,
-			std::tuple< TupleArgs... >,
-			std::void_t< decltype( T{ std::declval< TupleArgs >()... } ) >
-		>
-			: std::true_type {};
-
-		template< typename T, typename Tuple >
-		constexpr bool is_constructible_from_tuple_v= is_constructible_from_tuple< T, Tuple >::value;
-
-		template< typename T, typename InitTuple, std::size_t index= 0, typename= std::enable_if_t< std::is_aggregate_v< T > > >
+		constexpr bool is_constructible_from_tuple_v< T, std::tuple< TupleArgs... > >
+		{
+			ConstructibleFrom< T, TupleArgs... >
+		};
+	
+		template< Aggregate T, typename InitTuple, std::size_t index= 0 >
 		constexpr auto
 		build_base_tuple()
 		{
@@ -174,7 +170,7 @@ namespace Alepha::Hydrogen::Reflection
 			return 0;
 		}
 
-		template< typename T, std::size_t index= 0, typename= std::enable_if_t< std::is_aggregate_v< T > > >
+		template< Aggregate T, std::size_t index= 0 >
 		constexpr std::size_t
 		count_empty_bases()
 		{
diff --git a/Reflection/tuplizeAggregate.h b/Reflection/tuplizeAggregate.h
index 769d8c4..e631743 100644
--- a/Reflection/tuplizeAggregate.h
+++ b/Reflection/tuplizeAggregate.h
@@ -17,21 +17,18 @@ namespace Alepha::Hydrogen::Reflection
 	{
 		inline namespace exports {}
 
-		template< typename T, typename= void >
-		struct has_salient_members_constant : std::false_type {};
-
 		template< typename T >
-		struct has_salient_members_constant< T, std::void_t< decltype( T::salient_members ) > >
-			: std::true_type {};
-
-		template< typename T >
-		constexpr bool has_salient_members_constant_v= has_salient_members_constant< T >::value;
+		concept SalientMembers=
+		requires( const T &t )
+		{
+			{ T::salient_members } -> ConvertibleTo< std::size_t >;
+		};
 
 		template< typename T >
 		constexpr std::size_t
 		compute_salient_members_count_impl()
 		{
-			if constexpr( has_salient_members_constant_v< T > ) return T::salient_members;
+			if constexpr( SalientMembers< T > ) return T::salient_members;
 			else return aggregate_member_count_v< std::decay_t< T > >;
 		}