diff --git a/CHANGELOG.md b/CHANGELOG.md
index 70cfd3e..9d31e58 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@
 
 -   Fixed rvalue row corruption bug on MSVC ([info](https://developercommunity.visualstudio.com/t/C:-Corrupt-references-when-creating-a/10446877))
 -   Added `Cols...` selector template parameter to `at()`, `front()` and `back()`
+-   Added `structs.mixins`
+-   Added copy-based fallbacks for `unordered_erase()`, `insert()`, `emplace()` and `swap_columns()` (previously they required movability)
 
 ## v0.6.0
 
diff --git a/docs/pages/schema.md b/docs/pages/schema.md
index 8d614d2..144572b 100644
--- a/docs/pages/schema.md
+++ b/docs/pages/schema.md
@@ -1,8 +1,8 @@
-@page schema Config File Schema
+@page schema Config Schema
 
 @tableofcontents
 
-This is the config file schema for the `*.toml` configuration files that are used with `soagen`, a command-line tool
+This is the schema for the `*.toml` configuration files that are used with `soagen`, a command-line tool
 for generating SoA container classes for use in C++.
 
 @see <ul>
@@ -404,7 +404,7 @@ This code will be at class scope.
 
 @note You _could_ use this to inject functions, but writing C++ code in a toml config file isn't exactly the best
 user-experience. If you must do this, best practice would be to only use it for very simple functions like one-liner
-conversion operators, et cetera.
+conversion operators, et cetera. A better strategy is to use CRTP (see @ref schema_structs_mixins).
 
 <!-- --------------------------------------------------------------------------------------------------------------- -->
 
@@ -421,6 +421,40 @@ This code will be at class scope.
 
 <!-- --------------------------------------------------------------------------------------------------------------- -->
 
+@subsection schema_structs_mixins mixins
+
+List of type names to use as CRTP 'mixin' base classes. Each named type must be a template class that takes one type argument
+(additional template arguments are allowed but must be defaulted).
+
+**Type:** string, or array of strings
+
+**Required:** No
+
+**Default:** None
+
+**Example:**
+
+```toml
+[structs.particles]
+mixins = 'foo::add_some_functionality'
+```
+
+Where `foo::add_some_functionality` is something like this:
+
+```cpp
+namespace foo
+{
+	template <typename Derived>
+	struct add_some_functionality
+	{
+		// ...
+	};
+}
+
+```
+
+<!-- --------------------------------------------------------------------------------------------------------------- -->
+
 @subsection schema_structs_movable movable
 
 Used to disable the move constructor + assignment operator if necessary.
diff --git a/docs/poxy.toml b/docs/poxy.toml
index 3aeba24..2e20882 100644
--- a/docs/poxy.toml
+++ b/docs/poxy.toml
@@ -22,7 +22,7 @@ extra_files = [
 	'images/author.jpg',
 ]
 stylesheets = ['pages.css']
-navbar = ['pages', 'namespaces', 'classes']
+navbar = ['schema', 'pages', 'namespaces', 'classes']
 
 [warnings]
 enabled = true
diff --git a/examples/entities.hpp b/examples/entities.hpp
index 9cfbb25..b3385dd 100644
--- a/examples/entities.hpp
+++ b/examples/entities.hpp
@@ -139,7 +139,25 @@ namespace soagen::detail
 		#define SOAGEN_NAME_pos
 		SOAGEN_MAKE_NAME(pos);
 	#endif
+}
+
+namespace soagen_struct_impl_soagen_examples_entities
+{
+	SOAGEN_DISABLE_WARNINGS;
+	using namespace soagen::examples;
+	SOAGEN_ENABLE_WARNINGS;
+
+	using soagen_table_traits_type = soagen::table_traits<
+						/*	   id */ soagen::column_traits<unsigned>,
+						/*	 name */ soagen::column_traits<std::string>,
+						/*	  pos */ soagen::column_traits<vec3, soagen::max(std::size_t{ 32u }, alignof(vec3))>,
+						/* orient */ soagen::column_traits<quaternion>>;
 
+	using soagen_allocator_type = soagen::allocator;
+}
+
+namespace soagen::detail
+{
 	SOAGEN_MAKE_NAMED_COLUMN(soagen::examples::entities, 0, id);
 	SOAGEN_MAKE_NAMED_COLUMN(soagen::examples::entities, 1, name);
 	SOAGEN_MAKE_NAMED_COLUMN(soagen::examples::entities, 2, pos);
@@ -152,17 +170,13 @@ namespace soagen::detail
 	template <>
 	struct table_traits_type_<soagen::examples::entities>
 	{
-		using type = table_traits<
-		/*	   id */ column_traits<unsigned>,
-		/*	 name */ column_traits<std::string>,
-		/*	  pos */ column_traits<vec3, soagen::max(size_t{ 32 }, alignof(vec3))>,
-		/* orient */ column_traits<quaternion>>;
+		using type = soagen_struct_impl_soagen_examples_entities::soagen_table_traits_type;
 	};
 
 	template <>
 	struct allocator_type_<soagen::examples::entities>
 	{
-		using type = soagen::allocator;
+		using type = soagen_struct_impl_soagen_examples_entities::soagen_allocator_type;
 	};
 
 	template <>
@@ -397,7 +411,7 @@ namespace soagen::examples
 		/// @availability This method is only available when all the column types are move-assignable.
 		SOAGEN_HIDDEN(template <bool sfinae = soagen::has_erase_member<table_type>>)
 		SOAGEN_ALWAYS_INLINE
-		SOAGEN_CPP20_CONSTEXPR
+		SOAGEN_CPP20_CONSTEXPR									   //
 		SOAGEN_ENABLE_IF_T(entities&, sfinae) erase(size_type pos) //
 			noexcept(soagen::has_nothrow_erase_member<table_type>)
 		{
@@ -419,7 +433,7 @@ namespace soagen::examples
 		/// @availability This method is only available when all the column types are move-assignable.
 		SOAGEN_HIDDEN(template <bool sfinae = soagen::has_unordered_erase_member<table_type>>)
 		SOAGEN_ALWAYS_INLINE
-		SOAGEN_CPP20_CONSTEXPR
+		SOAGEN_CPP20_CONSTEXPR																   //
 		SOAGEN_ENABLE_IF_T(soagen::optional<size_type>, sfinae) unordered_erase(size_type pos) //
 			noexcept(soagen::has_nothrow_unordered_erase_member<table_type>)
 		{
@@ -551,7 +565,7 @@ namespace soagen::examples
 							column_traits<1>::param_type name	= "",
 							column_traits<2>::param_type pos	= {},
 							column_traits<3>::param_type orient = { 1, 0, 0, 0 }) //
-			noexcept(table_traits::push_back_is_nothrow<table_type&>)
+			noexcept(table_traits::push_back_is_nothrow<table_type>)			  //
 		{
 			table_.emplace_back(static_cast<column_traits<0>::param_forward_type>(id),
 								static_cast<column_traits<1>::param_forward_type>(name),
@@ -561,14 +575,14 @@ namespace soagen::examples
 		}
 
 		/// @brief Adds a new row at the end of the table (rvalue overload).
-		SOAGEN_HIDDEN(template <bool sfinae = table_traits::rvalue_type_list_is_distinct>)
+		SOAGEN_HIDDEN(template <bool sfinae = table_traits::rvalues_are_distinct>)
 		SOAGEN_CPP20_CONSTEXPR
 		entities& push_back(SOAGEN_ENABLE_IF_T(column_traits<0>::rvalue_type, sfinae) id,
 							column_traits<1>::rvalue_type name	 = "",
 							column_traits<2>::rvalue_type pos	 = {},
 							column_traits<3>::rvalue_type orient = { 1, 0, 0, 0 }) //
-			noexcept(table_traits::rvalue_push_back_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct) //
+			noexcept(table_traits::rvalue_push_back_is_nothrow<table_type>)		   //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct)					   //
 		{
 			table_.emplace_back(static_cast<column_traits<0>::rvalue_forward_type>(id),
 								static_cast<column_traits<1>::rvalue_forward_type>(name),
@@ -585,8 +599,8 @@ namespace soagen::examples
 					  table_traits::row_constructible_from<Id&&, Name&&, Pos&&, Orient&&>)>
 		SOAGEN_CPP20_CONSTEXPR
 		entities& emplace_back(Id&& id, Name&& name = "", Pos&& pos = {}, Orient&& orient = { 1, 0, 0, 0 }) //
-			noexcept(table_traits::emplace_back_is_nothrow<table_type&, Id&&, Name&&, Pos&&, Orient&&>)
-				SOAGEN_REQUIRES(table_traits::row_constructible_from<Id&&, Name&&, Pos&&, Orient&&>) //
+			noexcept(table_traits::emplace_back_is_nothrow<table_type, Id&&, Name&&, Pos&&, Orient&&>)		//
+			SOAGEN_REQUIRES(table_traits::row_constructible_from<Id&&, Name&&, Pos&&, Orient&&>)			//
 		{
 			table_.emplace_back(static_cast<Id&&>(id),
 								static_cast<Name&&>(name),
@@ -596,12 +610,11 @@ namespace soagen::examples
 		}
 
 		/// @brief Constructs a new row directly in-place at the end of the table by unpacking a tuple-like object.
-		template <typename Tuple SOAGEN_ENABLE_IF(
-			(table_traits::row_constructible_from<Tuple&&> && table_traits::row_constructible_from<Tuple&&>))>
+		template <typename Tuple SOAGEN_ENABLE_IF(table_traits::row_constructible_from<Tuple&&>)>
 		SOAGEN_CPP20_CONSTEXPR
-		entities& emplace_back(Tuple&& tuple_) //
-			noexcept(table_traits::emplace_back_is_nothrow<table_type&, Tuple&&>) SOAGEN_REQUIRES(
-				table_traits::row_constructible_from<Tuple&&>&& table_traits::row_constructible_from<Tuple&&>) //
+		entities& emplace_back(Tuple&& tuple_)									 //
+			noexcept(table_traits::emplace_back_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(table_traits::row_constructible_from<Tuple&&>)		 //
 		{
 			table_.emplace_back(static_cast<Tuple&&>(tuple_));
 			return *this;
@@ -616,17 +629,17 @@ namespace soagen::examples
 		/// @brief Inserts a new row at an arbitrary position in the table.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::all_move_constructible && table_traits::all_move_assignable)>
+		SOAGEN_HIDDEN(template <bool sfinae = (table_traits::all_move_or_copy_constructible
+											   && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		SOAGEN_ENABLE_IF_T(entities&, sfinae) insert(size_type index_,
 													 column_traits<0>::param_type id,
 													 column_traits<1>::param_type name	 = "",
 													 column_traits<2>::param_type pos	 = {},
-													 column_traits<3>::param_type orient = { 1, 0, 0, 0 }) //
-			noexcept(table_traits::insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable) //
+													 column_traits<3>::param_type orient = { 1, 0, 0, 0 })			  //
+			noexcept(table_traits::insert_is_nothrow<table_type>)													  //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(index_,
 						   static_cast<column_traits<0>::param_forward_type>(id),
@@ -639,17 +652,17 @@ namespace soagen::examples
 		/// @brief Inserts a new row at an arbitrary position in the table.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::all_move_constructible && table_traits::all_move_assignable)>
+		SOAGEN_HIDDEN(template <bool sfinae = (table_traits::all_move_or_copy_constructible
+											   && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		SOAGEN_ENABLE_IF_T(iterator, sfinae) insert(iterator iter_,
 													column_traits<0>::param_type id,
 													column_traits<1>::param_type name	= "",
 													column_traits<2>::param_type pos	= {},
-													column_traits<3>::param_type orient = { 1, 0, 0, 0 }) //
-			noexcept(table_traits::insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable) //
+													column_traits<3>::param_type orient = { 1, 0, 0, 0 })			  //
+			noexcept(table_traits::insert_is_nothrow<table_type>)													  //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::param_forward_type>(id),
@@ -662,17 +675,17 @@ namespace soagen::examples
 		/// @brief Inserts a new row at an arbitrary position in the table.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::all_move_constructible && table_traits::all_move_assignable)>
+		SOAGEN_HIDDEN(template <bool sfinae = (table_traits::all_move_or_copy_constructible
+											   && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		SOAGEN_ENABLE_IF_T(const_iterator, sfinae) insert(const_iterator iter_,
 														  column_traits<0>::param_type id,
 														  column_traits<1>::param_type name	  = "",
 														  column_traits<2>::param_type pos	  = {},
-														  column_traits<3>::param_type orient = { 1, 0, 0, 0 }) //
-			noexcept(table_traits::insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable) //
+														  column_traits<3>::param_type orient = { 1, 0, 0, 0 })		  //
+			noexcept(table_traits::insert_is_nothrow<table_type>)													  //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::param_forward_type>(id),
@@ -686,8 +699,8 @@ namespace soagen::examples
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
 		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::rvalue_type_list_is_distinct && table_traits::all_move_constructible
-									 && table_traits::all_move_assignable)>
+			template <bool sfinae = (table_traits::rvalues_are_distinct && table_traits::all_move_or_copy_constructible
+									 && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		entities& insert(SOAGEN_ENABLE_IF_T(size_type, sfinae) index_,
@@ -695,9 +708,9 @@ namespace soagen::examples
 						 column_traits<1>::rvalue_type name	  = "",
 						 column_traits<2>::rvalue_type pos	  = {},
 						 column_traits<3>::rvalue_type orient = { 1, 0, 0, 0 }) //
-			noexcept(table_traits::rvalue_insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable) //
+			noexcept(table_traits::rvalue_insert_is_nothrow<table_type>)		//
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct&& table_traits::all_move_or_copy_constructible&&
+								table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(index_,
 						   static_cast<column_traits<0>::rvalue_forward_type>(id),
@@ -711,8 +724,8 @@ namespace soagen::examples
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
 		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::rvalue_type_list_is_distinct && table_traits::all_move_constructible
-									 && table_traits::all_move_assignable)>
+			template <bool sfinae = (table_traits::rvalues_are_distinct && table_traits::all_move_or_copy_constructible
+									 && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		iterator insert(SOAGEN_ENABLE_IF_T(iterator, sfinae) iter_,
@@ -720,9 +733,9 @@ namespace soagen::examples
 						column_traits<1>::rvalue_type name	 = "",
 						column_traits<2>::rvalue_type pos	 = {},
 						column_traits<3>::rvalue_type orient = { 1, 0, 0, 0 }) //
-			noexcept(table_traits::rvalue_insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable) //
+			noexcept(table_traits::rvalue_insert_is_nothrow<table_type>)	   //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct&& table_traits::all_move_or_copy_constructible&&
+								table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::rvalue_forward_type>(id),
@@ -736,8 +749,8 @@ namespace soagen::examples
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
 		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::rvalue_type_list_is_distinct && table_traits::all_move_constructible
-									 && table_traits::all_move_assignable)>
+			template <bool sfinae = (table_traits::rvalues_are_distinct && table_traits::all_move_or_copy_constructible
+									 && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		const_iterator insert(SOAGEN_ENABLE_IF_T(const_iterator, sfinae) iter_,
@@ -745,9 +758,9 @@ namespace soagen::examples
 							  column_traits<1>::rvalue_type name   = "",
 							  column_traits<2>::rvalue_type pos	   = {},
 							  column_traits<3>::rvalue_type orient = { 1, 0, 0, 0 }) //
-			noexcept(table_traits::rvalue_insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable) //
+			noexcept(table_traits::rvalue_insert_is_nothrow<table_type>)			 //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct&& table_traits::all_move_or_copy_constructible&&
+								table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::rvalue_forward_type>(id),
@@ -764,17 +777,17 @@ namespace soagen::examples
 				  typename Name	  = column_traits<1>::default_emplace_type,
 				  typename Pos	  = column_traits<2>::default_emplace_type,
 				  typename Orient = column_traits<3>::default_emplace_type SOAGEN_ENABLE_IF(
-					  (table_traits::all_move_constructible && table_traits::all_move_assignable
+					  (table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable
 					   && table_traits::row_constructible_from<Id&&, Name&&, Pos&&, Orient&&>))>
 		SOAGEN_CPP20_CONSTEXPR
 		entities& emplace(size_type index_,
 						  Id&& id,
 						  Name&& name	  = "",
 						  Pos&& pos		  = {},
-						  Orient&& orient = { 1, 0, 0, 0 }) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Id&&, Name&&, Pos&&, Orient&&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable&&
-									table_traits::row_constructible_from<Id&&, Name&&, Pos&&, Orient&&>) //
+						  Orient&& orient = { 1, 0, 0, 0 })										  //
+			noexcept(table_traits::emplace_is_nothrow<table_type, Id&&, Name&&, Pos&&, Orient&&>) //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable&&
+								table_traits::row_constructible_from<Id&&, Name&&, Pos&&, Orient&&>) //
 		{
 			table_.emplace(index_,
 						   static_cast<Id&&>(id),
@@ -791,13 +804,13 @@ namespace soagen::examples
 				  typename Name	  = column_traits<1>::default_emplace_type,
 				  typename Pos	  = column_traits<2>::default_emplace_type,
 				  typename Orient = column_traits<3>::default_emplace_type SOAGEN_ENABLE_IF(
-					  (table_traits::all_move_constructible && table_traits::all_move_assignable
+					  (table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable
 					   && table_traits::row_constructible_from<Id&&, Name&&, Pos&&, Orient&&>))>
 		SOAGEN_CPP20_CONSTEXPR
 		iterator emplace(iterator iter_, Id&& id, Name&& name = "", Pos&& pos = {}, Orient&& orient = { 1, 0, 0, 0 }) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Id&&, Name&&, Pos&&, Orient&&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable&&
-									table_traits::row_constructible_from<Id&&, Name&&, Pos&&, Orient&&>) //
+			noexcept(table_traits::emplace_is_nothrow<table_type, Id&&, Name&&, Pos&&, Orient&&>)					  //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable&&
+								table_traits::row_constructible_from<Id&&, Name&&, Pos&&, Orient&&>) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<Id&&>(id),
@@ -814,17 +827,17 @@ namespace soagen::examples
 				  typename Name	  = column_traits<1>::default_emplace_type,
 				  typename Pos	  = column_traits<2>::default_emplace_type,
 				  typename Orient = column_traits<3>::default_emplace_type SOAGEN_ENABLE_IF(
-					  (table_traits::all_move_constructible && table_traits::all_move_assignable
+					  (table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable
 					   && table_traits::row_constructible_from<Id&&, Name&&, Pos&&, Orient&&>))>
 		SOAGEN_CPP20_CONSTEXPR
 		const_iterator emplace(const_iterator iter_,
 							   Id&& id,
 							   Name&& name	   = "",
 							   Pos&& pos	   = {},
-							   Orient&& orient = { 1, 0, 0, 0 }) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Id&&, Name&&, Pos&&, Orient&&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable&&
-									table_traits::row_constructible_from<Id&&, Name&&, Pos&&, Orient&&>) //
+							   Orient&& orient = { 1, 0, 0, 0 })								  //
+			noexcept(table_traits::emplace_is_nothrow<table_type, Id&&, Name&&, Pos&&, Orient&&>) //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable&&
+								table_traits::row_constructible_from<Id&&, Name&&, Pos&&, Orient&&>) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<Id&&>(id),
@@ -837,14 +850,15 @@ namespace soagen::examples
 		/// @brief Constructs a new row directly in-place at an arbitrary position in the table by unpacking a tuple-like object.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		template <typename Tuple SOAGEN_ENABLE_IF(
-			(table_traits::row_constructible_from<Tuple&&> && table_traits::all_move_constructible
-			 && table_traits::all_move_assignable && table_traits::row_constructible_from<size_type, Tuple&&>))>
+		template <typename Tuple SOAGEN_ENABLE_IF((table_traits::row_constructible_from<Tuple&&>
+												   && table_traits::all_move_or_copy_constructible
+												   && table_traits::all_move_or_copy_assignable))>
 		SOAGEN_CPP20_CONSTEXPR
-		entities& emplace(size_type index_, Tuple&& tuple_) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Tuple&&>) SOAGEN_REQUIRES(
-				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_constructible&&
-					table_traits::all_move_assignable&& table_traits::row_constructible_from<size_type, Tuple&&>) //
+		entities& emplace(size_type index_, Tuple&& tuple_)					//
+			noexcept(table_traits::emplace_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_or_copy_constructible&&
+					table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(index_, static_cast<Tuple&&>(tuple_));
 			return *this;
@@ -853,14 +867,15 @@ namespace soagen::examples
 		/// @brief Constructs a new row directly in-place at an arbitrary position in the table by unpacking a tuple-like object.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		template <typename Tuple SOAGEN_ENABLE_IF(
-			(table_traits::row_constructible_from<Tuple&&> && table_traits::all_move_constructible
-			 && table_traits::all_move_assignable && table_traits::row_constructible_from<iterator, Tuple&&>))>
+		template <typename Tuple SOAGEN_ENABLE_IF((table_traits::row_constructible_from<Tuple&&>
+												   && table_traits::all_move_or_copy_constructible
+												   && table_traits::all_move_or_copy_assignable))>
 		SOAGEN_CPP20_CONSTEXPR
-		iterator emplace(iterator iter_, Tuple&& tuple_) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Tuple&&>) SOAGEN_REQUIRES(
-				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_constructible&&
-					table_traits::all_move_assignable&& table_traits::row_constructible_from<iterator, Tuple&&>) //
+		iterator emplace(iterator iter_, Tuple&& tuple_)					//
+			noexcept(table_traits::emplace_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_or_copy_constructible&&
+					table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_), static_cast<Tuple&&>(tuple_));
 			return iter_;
@@ -869,15 +884,15 @@ namespace soagen::examples
 		/// @brief Constructs a new row directly in-place at an arbitrary position in the table by unpacking a tuple-like object.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		template <typename Tuple SOAGEN_ENABLE_IF(
-			(table_traits::row_constructible_from<Tuple&&> && table_traits::all_move_constructible
-			 && table_traits::all_move_assignable && table_traits::row_constructible_from<const_iterator, Tuple&&>))>
+		template <typename Tuple SOAGEN_ENABLE_IF((table_traits::row_constructible_from<Tuple&&>
+												   && table_traits::all_move_or_copy_constructible
+												   && table_traits::all_move_or_copy_assignable))>
 		SOAGEN_CPP20_CONSTEXPR
-		const_iterator emplace(const_iterator iter_, Tuple&& tuple_) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Tuple&&>)
-				SOAGEN_REQUIRES(table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable&&
-										table_traits::row_constructible_from<const_iterator, Tuple&&>) //
+		const_iterator emplace(const_iterator iter_, Tuple&& tuple_)		//
+			noexcept(table_traits::emplace_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_or_copy_constructible&&
+					table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_), static_cast<Tuple&&>(tuple_));
 			return iter_;
diff --git a/examples/shapes.hpp b/examples/shapes.hpp
index 38cd115..10d9f2e 100644
--- a/examples/shapes.hpp
+++ b/examples/shapes.hpp
@@ -159,7 +159,43 @@ namespace soagen::detail
 		#define SOAGEN_NAME_radius
 		SOAGEN_MAKE_NAME(radius);
 	#endif
+}
+
+namespace soagen_struct_impl_soagen_examples_boxes
+{
+	SOAGEN_DISABLE_WARNINGS;
+	using namespace soagen::examples;
+	SOAGEN_ENABLE_WARNINGS;
+
+	using soagen_table_traits_type = soagen::table_traits<
+					 /*  center_x */ soagen::column_traits<float, soagen::max(std::size_t{ 32u }, alignof(float))>,
+					 /*  center_y */ soagen::column_traits<float, soagen::max(std::size_t{ 32u }, alignof(float))>,
+					 /*  center_z */ soagen::column_traits<float, soagen::max(std::size_t{ 32u }, alignof(float))>,
+					 /* extents_x */ soagen::column_traits<float, soagen::max(std::size_t{ 32u }, alignof(float))>,
+					 /* extents_y */ soagen::column_traits<float, soagen::max(std::size_t{ 32u }, alignof(float))>,
+					 /* extents_z */ soagen::column_traits<float, soagen::max(std::size_t{ 32u }, alignof(float))>,
+					 /* 	 mass */ soagen::column_traits<float>>;
+
+	using soagen_allocator_type = soagen::allocator;
+}
+namespace soagen_struct_impl_soagen_examples_spheres
+{
+	SOAGEN_DISABLE_WARNINGS;
+	using namespace soagen::examples;
+	SOAGEN_ENABLE_WARNINGS;
+
+	using soagen_table_traits_type = soagen::table_traits<
+					  /* center_x */ soagen::column_traits<float, soagen::max(std::size_t{ 32u }, alignof(float))>,
+					  /* center_y */ soagen::column_traits<float, soagen::max(std::size_t{ 32u }, alignof(float))>,
+					  /* center_z */ soagen::column_traits<float, soagen::max(std::size_t{ 32u }, alignof(float))>,
+					  /*   radius */ soagen::column_traits<float, soagen::max(std::size_t{ 32u }, alignof(float))>,
+					  /*	 mass */ soagen::column_traits<float>>;
+
+	using soagen_allocator_type = soagen::allocator;
+}
 
+namespace soagen::detail
+{
 	SOAGEN_MAKE_NAMED_COLUMN(soagen::examples::boxes, 0, center_x);
 	SOAGEN_MAKE_NAMED_COLUMN(soagen::examples::boxes, 1, center_y);
 	SOAGEN_MAKE_NAMED_COLUMN(soagen::examples::boxes, 2, center_z);
@@ -175,20 +211,13 @@ namespace soagen::detail
 	template <>
 	struct table_traits_type_<soagen::examples::boxes>
 	{
-		using type = table_traits<
-		/*	center_x */ column_traits<float, soagen::max(size_t{ 32 }, alignof(float))>,
-		/*	center_y */ column_traits<float, soagen::max(size_t{ 32 }, alignof(float))>,
-		/*	center_z */ column_traits<float, soagen::max(size_t{ 32 }, alignof(float))>,
-		/* extents_x */ column_traits<float, soagen::max(size_t{ 32 }, alignof(float))>,
-		/* extents_y */ column_traits<float, soagen::max(size_t{ 32 }, alignof(float))>,
-		/* extents_z */ column_traits<float, soagen::max(size_t{ 32 }, alignof(float))>,
-		/*		mass */ column_traits<float>>;
+		using type = soagen_struct_impl_soagen_examples_boxes::soagen_table_traits_type;
 	};
 
 	template <>
 	struct allocator_type_<soagen::examples::boxes>
 	{
-		using type = soagen::allocator;
+		using type = soagen_struct_impl_soagen_examples_boxes::soagen_allocator_type;
 	};
 
 	template <>
@@ -210,18 +239,13 @@ namespace soagen::detail
 	template <>
 	struct table_traits_type_<soagen::examples::spheres>
 	{
-		using type = table_traits<
-		/* center_x */ column_traits<float, soagen::max(size_t{ 32 }, alignof(float))>,
-		/* center_y */ column_traits<float, soagen::max(size_t{ 32 }, alignof(float))>,
-		/* center_z */ column_traits<float, soagen::max(size_t{ 32 }, alignof(float))>,
-		/*	 radius */ column_traits<float, soagen::max(size_t{ 32 }, alignof(float))>,
-		/*	   mass */ column_traits<float>>;
+		using type = soagen_struct_impl_soagen_examples_spheres::soagen_table_traits_type;
 	};
 
 	template <>
 	struct allocator_type_<soagen::examples::spheres>
 	{
-		using type = soagen::allocator;
+		using type = soagen_struct_impl_soagen_examples_spheres::soagen_allocator_type;
 	};
 
 	template <>
@@ -474,7 +498,7 @@ namespace soagen::examples
 		/// @availability This method is only available when all the column types are move-assignable.
 		SOAGEN_HIDDEN(template <bool sfinae = soagen::has_erase_member<table_type>>)
 		SOAGEN_ALWAYS_INLINE
-		SOAGEN_CPP20_CONSTEXPR
+		SOAGEN_CPP20_CONSTEXPR									//
 		SOAGEN_ENABLE_IF_T(boxes&, sfinae) erase(size_type pos) //
 			noexcept(soagen::has_nothrow_erase_member<table_type>)
 		{
@@ -496,7 +520,7 @@ namespace soagen::examples
 		/// @availability This method is only available when all the column types are move-assignable.
 		SOAGEN_HIDDEN(template <bool sfinae = soagen::has_unordered_erase_member<table_type>>)
 		SOAGEN_ALWAYS_INLINE
-		SOAGEN_CPP20_CONSTEXPR
+		SOAGEN_CPP20_CONSTEXPR																   //
 		SOAGEN_ENABLE_IF_T(soagen::optional<size_type>, sfinae) unordered_erase(size_type pos) //
 			noexcept(soagen::has_nothrow_unordered_erase_member<table_type>)
 		{
@@ -631,7 +655,7 @@ namespace soagen::examples
 						 column_traits<4>::param_type extents_y = 0.5,
 						 column_traits<5>::param_type extents_z = 0.5,
 						 column_traits<6>::param_type mass		= default_mass) //
-			noexcept(table_traits::push_back_is_nothrow<table_type&>)
+			noexcept(table_traits::push_back_is_nothrow<table_type>)	   //
 		{
 			table_.emplace_back(static_cast<column_traits<0>::param_forward_type>(center_x),
 								static_cast<column_traits<1>::param_forward_type>(center_y),
@@ -644,7 +668,7 @@ namespace soagen::examples
 		}
 
 		/// @brief Adds a new row at the end of the table (rvalue overload).
-		SOAGEN_HIDDEN(template <bool sfinae = table_traits::rvalue_type_list_is_distinct>)
+		SOAGEN_HIDDEN(template <bool sfinae = table_traits::rvalues_are_distinct>)
 		SOAGEN_CPP20_CONSTEXPR
 		boxes& push_back(SOAGEN_ENABLE_IF_T(column_traits<0>::rvalue_type, sfinae) center_x,
 						 column_traits<1>::rvalue_type center_y,
@@ -653,8 +677,8 @@ namespace soagen::examples
 						 column_traits<4>::rvalue_type extents_y = 0.5,
 						 column_traits<5>::rvalue_type extents_z = 0.5,
 						 column_traits<6>::rvalue_type mass		 = default_mass) //
-			noexcept(table_traits::rvalue_push_back_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct) //
+			noexcept(table_traits::rvalue_push_back_is_nothrow<table_type>) //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct)				//
 		{
 			table_.emplace_back(static_cast<column_traits<0>::rvalue_forward_type>(center_x),
 								static_cast<column_traits<1>::rvalue_forward_type>(center_y),
@@ -689,21 +713,21 @@ namespace soagen::examples
 							ExtentsY&& extents_y = 0.5,
 							ExtentsZ&& extents_z = 0.5,
 							Mass&& mass			 = default_mass) //
-			noexcept(table_traits::emplace_back_is_nothrow<table_type&,
+			noexcept(table_traits::emplace_back_is_nothrow<table_type,
 														   CenterX&&,
 														   CenterY&&,
 														   CenterZ&&,
 														   ExtentsX&&,
 														   ExtentsY&&,
 														   ExtentsZ&&,
-														   Mass&&>)
-				SOAGEN_REQUIRES(table_traits::row_constructible_from<CenterX&&,
-																	 CenterY&&,
-																	 CenterZ&&,
-																	 ExtentsX&&,
-																	 ExtentsY&&,
-																	 ExtentsZ&&,
-																	 Mass&&>) //
+														   Mass&&>) //
+			SOAGEN_REQUIRES(table_traits::row_constructible_from<CenterX&&,
+																 CenterY&&,
+																 CenterZ&&,
+																 ExtentsX&&,
+																 ExtentsY&&,
+																 ExtentsZ&&,
+																 Mass&&>) //
 		{
 			table_.emplace_back(static_cast<CenterX&&>(center_x),
 								static_cast<CenterY&&>(center_y),
@@ -716,12 +740,11 @@ namespace soagen::examples
 		}
 
 		/// @brief Constructs a new row directly in-place at the end of the table by unpacking a tuple-like object.
-		template <typename Tuple SOAGEN_ENABLE_IF(
-			(table_traits::row_constructible_from<Tuple&&> && table_traits::row_constructible_from<Tuple&&>))>
+		template <typename Tuple SOAGEN_ENABLE_IF(table_traits::row_constructible_from<Tuple&&>)>
 		SOAGEN_CPP20_CONSTEXPR
-		boxes& emplace_back(Tuple&& tuple_) //
-			noexcept(table_traits::emplace_back_is_nothrow<table_type&, Tuple&&>) SOAGEN_REQUIRES(
-				table_traits::row_constructible_from<Tuple&&>&& table_traits::row_constructible_from<Tuple&&>) //
+		boxes& emplace_back(Tuple&& tuple_)										 //
+			noexcept(table_traits::emplace_back_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(table_traits::row_constructible_from<Tuple&&>)		 //
 		{
 			table_.emplace_back(static_cast<Tuple&&>(tuple_));
 			return *this;
@@ -736,8 +759,8 @@ namespace soagen::examples
 		/// @brief Inserts a new row at an arbitrary position in the table.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::all_move_constructible && table_traits::all_move_assignable)>
+		SOAGEN_HIDDEN(template <bool sfinae = (table_traits::all_move_or_copy_constructible
+											   && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		SOAGEN_ENABLE_IF_T(boxes&, sfinae) insert(size_type index_,
@@ -747,9 +770,9 @@ namespace soagen::examples
 												  column_traits<3>::param_type extents_x = 0.5,
 												  column_traits<4>::param_type extents_y = 0.5,
 												  column_traits<5>::param_type extents_z = 0.5,
-												  column_traits<6>::param_type mass		 = default_mass) //
-			noexcept(table_traits::insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable) //
+												  column_traits<6>::param_type mass		 = default_mass)					  //
+			noexcept(table_traits::insert_is_nothrow<table_type>)													  //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(index_,
 						   static_cast<column_traits<0>::param_forward_type>(center_x),
@@ -765,8 +788,8 @@ namespace soagen::examples
 		/// @brief Inserts a new row at an arbitrary position in the table.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::all_move_constructible && table_traits::all_move_assignable)>
+		SOAGEN_HIDDEN(template <bool sfinae = (table_traits::all_move_or_copy_constructible
+											   && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		SOAGEN_ENABLE_IF_T(iterator, sfinae) insert(iterator iter_,
@@ -776,9 +799,9 @@ namespace soagen::examples
 													column_traits<3>::param_type extents_x = 0.5,
 													column_traits<4>::param_type extents_y = 0.5,
 													column_traits<5>::param_type extents_z = 0.5,
-													column_traits<6>::param_type mass	   = default_mass) //
-			noexcept(table_traits::insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable) //
+													column_traits<6>::param_type mass	   = default_mass)				  //
+			noexcept(table_traits::insert_is_nothrow<table_type>)													  //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::param_forward_type>(center_x),
@@ -794,8 +817,8 @@ namespace soagen::examples
 		/// @brief Inserts a new row at an arbitrary position in the table.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::all_move_constructible && table_traits::all_move_assignable)>
+		SOAGEN_HIDDEN(template <bool sfinae = (table_traits::all_move_or_copy_constructible
+											   && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		SOAGEN_ENABLE_IF_T(const_iterator, sfinae) insert(const_iterator iter_,
@@ -805,9 +828,9 @@ namespace soagen::examples
 														  column_traits<3>::param_type extents_x = 0.5,
 														  column_traits<4>::param_type extents_y = 0.5,
 														  column_traits<5>::param_type extents_z = 0.5,
-														  column_traits<6>::param_type mass		 = default_mass) //
-			noexcept(table_traits::insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable) //
+														  column_traits<6>::param_type mass		 = default_mass)			  //
+			noexcept(table_traits::insert_is_nothrow<table_type>)													  //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::param_forward_type>(center_x),
@@ -824,8 +847,8 @@ namespace soagen::examples
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
 		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::rvalue_type_list_is_distinct && table_traits::all_move_constructible
-									 && table_traits::all_move_assignable)>
+			template <bool sfinae = (table_traits::rvalues_are_distinct && table_traits::all_move_or_copy_constructible
+									 && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		boxes& insert(SOAGEN_ENABLE_IF_T(size_type, sfinae) index_,
@@ -836,9 +859,9 @@ namespace soagen::examples
 					  column_traits<4>::rvalue_type extents_y = 0.5,
 					  column_traits<5>::rvalue_type extents_z = 0.5,
 					  column_traits<6>::rvalue_type mass	  = default_mass) //
-			noexcept(table_traits::rvalue_insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable) //
+			noexcept(table_traits::rvalue_insert_is_nothrow<table_type>) //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct&& table_traits::all_move_or_copy_constructible&&
+								table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(index_,
 						   static_cast<column_traits<0>::rvalue_forward_type>(center_x),
@@ -855,8 +878,8 @@ namespace soagen::examples
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
 		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::rvalue_type_list_is_distinct && table_traits::all_move_constructible
-									 && table_traits::all_move_assignable)>
+			template <bool sfinae = (table_traits::rvalues_are_distinct && table_traits::all_move_or_copy_constructible
+									 && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		iterator insert(SOAGEN_ENABLE_IF_T(iterator, sfinae) iter_,
@@ -867,9 +890,9 @@ namespace soagen::examples
 						column_traits<4>::rvalue_type extents_y = 0.5,
 						column_traits<5>::rvalue_type extents_z = 0.5,
 						column_traits<6>::rvalue_type mass		= default_mass) //
-			noexcept(table_traits::rvalue_insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable) //
+			noexcept(table_traits::rvalue_insert_is_nothrow<table_type>)   //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct&& table_traits::all_move_or_copy_constructible&&
+								table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::rvalue_forward_type>(center_x),
@@ -886,8 +909,8 @@ namespace soagen::examples
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
 		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::rvalue_type_list_is_distinct && table_traits::all_move_constructible
-									 && table_traits::all_move_assignable)>
+			template <bool sfinae = (table_traits::rvalues_are_distinct && table_traits::all_move_or_copy_constructible
+									 && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		const_iterator insert(SOAGEN_ENABLE_IF_T(const_iterator, sfinae) iter_,
@@ -898,9 +921,9 @@ namespace soagen::examples
 							  column_traits<4>::rvalue_type extents_y = 0.5,
 							  column_traits<5>::rvalue_type extents_z = 0.5,
 							  column_traits<6>::rvalue_type mass	  = default_mass) //
-			noexcept(table_traits::rvalue_insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable) //
+			noexcept(table_traits::rvalue_insert_is_nothrow<table_type>)		 //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct&& table_traits::all_move_or_copy_constructible&&
+								table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::rvalue_forward_type>(center_x),
@@ -923,7 +946,7 @@ namespace soagen::examples
 				  typename ExtentsY = column_traits<4>::default_emplace_type,
 				  typename ExtentsZ = column_traits<5>::default_emplace_type,
 				  typename Mass		= column_traits<6>::default_emplace_type SOAGEN_ENABLE_IF(
-					  (table_traits::all_move_constructible && table_traits::all_move_assignable
+					  (table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable
 					   && table_traits::row_constructible_from<CenterX&&,
 															   CenterY&&,
 															   CenterZ&&,
@@ -940,22 +963,22 @@ namespace soagen::examples
 					   ExtentsY&& extents_y = 0.5,
 					   ExtentsZ&& extents_z = 0.5,
 					   Mass&& mass			= default_mass) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&,
+			noexcept(table_traits::emplace_is_nothrow<table_type,
 													  CenterX&&,
 													  CenterY&&,
 													  CenterZ&&,
 													  ExtentsX&&,
 													  ExtentsY&&,
 													  ExtentsZ&&,
-													  Mass&&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable&&
-									table_traits::row_constructible_from<CenterX&&,
-																		 CenterY&&,
-																		 CenterZ&&,
-																		 ExtentsX&&,
-																		 ExtentsY&&,
-																		 ExtentsZ&&,
-																		 Mass&&>) //
+													  Mass&&>) //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable&&
+								table_traits::row_constructible_from<CenterX&&,
+																	 CenterY&&,
+																	 CenterZ&&,
+																	 ExtentsX&&,
+																	 ExtentsY&&,
+																	 ExtentsZ&&,
+																	 Mass&&>) //
 		{
 			table_.emplace(index_,
 						   static_cast<CenterX&&>(center_x),
@@ -978,7 +1001,7 @@ namespace soagen::examples
 				  typename ExtentsY = column_traits<4>::default_emplace_type,
 				  typename ExtentsZ = column_traits<5>::default_emplace_type,
 				  typename Mass		= column_traits<6>::default_emplace_type SOAGEN_ENABLE_IF(
-					  (table_traits::all_move_constructible && table_traits::all_move_assignable
+					  (table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable
 					   && table_traits::row_constructible_from<CenterX&&,
 															   CenterY&&,
 															   CenterZ&&,
@@ -995,22 +1018,22 @@ namespace soagen::examples
 						 ExtentsY&& extents_y = 0.5,
 						 ExtentsZ&& extents_z = 0.5,
 						 Mass&& mass		  = default_mass) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&,
+			noexcept(table_traits::emplace_is_nothrow<table_type,
 													  CenterX&&,
 													  CenterY&&,
 													  CenterZ&&,
 													  ExtentsX&&,
 													  ExtentsY&&,
 													  ExtentsZ&&,
-													  Mass&&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable&&
-									table_traits::row_constructible_from<CenterX&&,
-																		 CenterY&&,
-																		 CenterZ&&,
-																		 ExtentsX&&,
-																		 ExtentsY&&,
-																		 ExtentsZ&&,
-																		 Mass&&>) //
+													  Mass&&>) //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable&&
+								table_traits::row_constructible_from<CenterX&&,
+																	 CenterY&&,
+																	 CenterZ&&,
+																	 ExtentsX&&,
+																	 ExtentsY&&,
+																	 ExtentsZ&&,
+																	 Mass&&>) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<CenterX&&>(center_x),
@@ -1033,7 +1056,7 @@ namespace soagen::examples
 				  typename ExtentsY = column_traits<4>::default_emplace_type,
 				  typename ExtentsZ = column_traits<5>::default_emplace_type,
 				  typename Mass		= column_traits<6>::default_emplace_type SOAGEN_ENABLE_IF(
-					  (table_traits::all_move_constructible && table_traits::all_move_assignable
+					  (table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable
 					   && table_traits::row_constructible_from<CenterX&&,
 															   CenterY&&,
 															   CenterZ&&,
@@ -1050,22 +1073,22 @@ namespace soagen::examples
 							   ExtentsY&& extents_y = 0.5,
 							   ExtentsZ&& extents_z = 0.5,
 							   Mass&& mass			= default_mass) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&,
+			noexcept(table_traits::emplace_is_nothrow<table_type,
 													  CenterX&&,
 													  CenterY&&,
 													  CenterZ&&,
 													  ExtentsX&&,
 													  ExtentsY&&,
 													  ExtentsZ&&,
-													  Mass&&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable&&
-									table_traits::row_constructible_from<CenterX&&,
-																		 CenterY&&,
-																		 CenterZ&&,
-																		 ExtentsX&&,
-																		 ExtentsY&&,
-																		 ExtentsZ&&,
-																		 Mass&&>) //
+													  Mass&&>) //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable&&
+								table_traits::row_constructible_from<CenterX&&,
+																	 CenterY&&,
+																	 CenterZ&&,
+																	 ExtentsX&&,
+																	 ExtentsY&&,
+																	 ExtentsZ&&,
+																	 Mass&&>) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<CenterX&&>(center_x),
@@ -1081,14 +1104,15 @@ namespace soagen::examples
 		/// @brief Constructs a new row directly in-place at an arbitrary position in the table by unpacking a tuple-like object.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		template <typename Tuple SOAGEN_ENABLE_IF(
-			(table_traits::row_constructible_from<Tuple&&> && table_traits::all_move_constructible
-			 && table_traits::all_move_assignable && table_traits::row_constructible_from<size_type, Tuple&&>))>
+		template <typename Tuple SOAGEN_ENABLE_IF((table_traits::row_constructible_from<Tuple&&>
+												   && table_traits::all_move_or_copy_constructible
+												   && table_traits::all_move_or_copy_assignable))>
 		SOAGEN_CPP20_CONSTEXPR
-		boxes& emplace(size_type index_, Tuple&& tuple_) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Tuple&&>) SOAGEN_REQUIRES(
-				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_constructible&&
-					table_traits::all_move_assignable&& table_traits::row_constructible_from<size_type, Tuple&&>) //
+		boxes& emplace(size_type index_, Tuple&& tuple_)					//
+			noexcept(table_traits::emplace_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_or_copy_constructible&&
+					table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(index_, static_cast<Tuple&&>(tuple_));
 			return *this;
@@ -1097,14 +1121,15 @@ namespace soagen::examples
 		/// @brief Constructs a new row directly in-place at an arbitrary position in the table by unpacking a tuple-like object.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		template <typename Tuple SOAGEN_ENABLE_IF(
-			(table_traits::row_constructible_from<Tuple&&> && table_traits::all_move_constructible
-			 && table_traits::all_move_assignable && table_traits::row_constructible_from<iterator, Tuple&&>))>
+		template <typename Tuple SOAGEN_ENABLE_IF((table_traits::row_constructible_from<Tuple&&>
+												   && table_traits::all_move_or_copy_constructible
+												   && table_traits::all_move_or_copy_assignable))>
 		SOAGEN_CPP20_CONSTEXPR
-		iterator emplace(iterator iter_, Tuple&& tuple_) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Tuple&&>) SOAGEN_REQUIRES(
-				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_constructible&&
-					table_traits::all_move_assignable&& table_traits::row_constructible_from<iterator, Tuple&&>) //
+		iterator emplace(iterator iter_, Tuple&& tuple_)					//
+			noexcept(table_traits::emplace_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_or_copy_constructible&&
+					table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_), static_cast<Tuple&&>(tuple_));
 			return iter_;
@@ -1113,15 +1138,15 @@ namespace soagen::examples
 		/// @brief Constructs a new row directly in-place at an arbitrary position in the table by unpacking a tuple-like object.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		template <typename Tuple SOAGEN_ENABLE_IF(
-			(table_traits::row_constructible_from<Tuple&&> && table_traits::all_move_constructible
-			 && table_traits::all_move_assignable && table_traits::row_constructible_from<const_iterator, Tuple&&>))>
+		template <typename Tuple SOAGEN_ENABLE_IF((table_traits::row_constructible_from<Tuple&&>
+												   && table_traits::all_move_or_copy_constructible
+												   && table_traits::all_move_or_copy_assignable))>
 		SOAGEN_CPP20_CONSTEXPR
-		const_iterator emplace(const_iterator iter_, Tuple&& tuple_) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Tuple&&>)
-				SOAGEN_REQUIRES(table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable&&
-										table_traits::row_constructible_from<const_iterator, Tuple&&>) //
+		const_iterator emplace(const_iterator iter_, Tuple&& tuple_)		//
+			noexcept(table_traits::emplace_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_or_copy_constructible&&
+					table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_), static_cast<Tuple&&>(tuple_));
 			return iter_;
@@ -1684,7 +1709,7 @@ namespace soagen::examples
 		/// @availability This method is only available when all the column types are move-assignable.
 		SOAGEN_HIDDEN(template <bool sfinae = soagen::has_erase_member<table_type>>)
 		SOAGEN_ALWAYS_INLINE
-		SOAGEN_CPP20_CONSTEXPR
+		SOAGEN_CPP20_CONSTEXPR									  //
 		SOAGEN_ENABLE_IF_T(spheres&, sfinae) erase(size_type pos) //
 			noexcept(soagen::has_nothrow_erase_member<table_type>)
 		{
@@ -1706,7 +1731,7 @@ namespace soagen::examples
 		/// @availability This method is only available when all the column types are move-assignable.
 		SOAGEN_HIDDEN(template <bool sfinae = soagen::has_unordered_erase_member<table_type>>)
 		SOAGEN_ALWAYS_INLINE
-		SOAGEN_CPP20_CONSTEXPR
+		SOAGEN_CPP20_CONSTEXPR																   //
 		SOAGEN_ENABLE_IF_T(soagen::optional<size_type>, sfinae) unordered_erase(size_type pos) //
 			noexcept(soagen::has_nothrow_unordered_erase_member<table_type>)
 		{
@@ -1839,7 +1864,7 @@ namespace soagen::examples
 						   column_traits<2>::param_type center_z,
 						   column_traits<3>::param_type radius = 0.5,
 						   column_traits<4>::param_type mass   = default_mass) //
-			noexcept(table_traits::push_back_is_nothrow<table_type&>)
+			noexcept(table_traits::push_back_is_nothrow<table_type>)		 //
 		{
 			table_.emplace_back(static_cast<column_traits<0>::param_forward_type>(center_x),
 								static_cast<column_traits<1>::param_forward_type>(center_y),
@@ -1850,15 +1875,15 @@ namespace soagen::examples
 		}
 
 		/// @brief Adds a new row at the end of the table (rvalue overload).
-		SOAGEN_HIDDEN(template <bool sfinae = table_traits::rvalue_type_list_is_distinct>)
+		SOAGEN_HIDDEN(template <bool sfinae = table_traits::rvalues_are_distinct>)
 		SOAGEN_CPP20_CONSTEXPR
 		spheres& push_back(SOAGEN_ENABLE_IF_T(column_traits<0>::rvalue_type, sfinae) center_x,
 						   column_traits<1>::rvalue_type center_y,
 						   column_traits<2>::rvalue_type center_z,
 						   column_traits<3>::rvalue_type radius = 0.5,
 						   column_traits<4>::rvalue_type mass	= default_mass) //
-			noexcept(table_traits::rvalue_push_back_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct) //
+			noexcept(table_traits::rvalue_push_back_is_nothrow<table_type>)	  //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct)				  //
 		{
 			table_.emplace_back(static_cast<column_traits<0>::rvalue_forward_type>(center_x),
 								static_cast<column_traits<1>::rvalue_forward_type>(center_y),
@@ -1882,9 +1907,8 @@ namespace soagen::examples
 							  Radius&& radius = 0.5,
 							  Mass&& mass	  = default_mass) //
 			noexcept(
-				table_traits::emplace_back_is_nothrow<table_type&, CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>)
-				SOAGEN_REQUIRES(
-					table_traits::row_constructible_from<CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>) //
+				table_traits::emplace_back_is_nothrow<table_type, CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>) //
+			SOAGEN_REQUIRES(table_traits::row_constructible_from<CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>)  //
 		{
 			table_.emplace_back(static_cast<CenterX&&>(center_x),
 								static_cast<CenterY&&>(center_y),
@@ -1895,12 +1919,11 @@ namespace soagen::examples
 		}
 
 		/// @brief Constructs a new row directly in-place at the end of the table by unpacking a tuple-like object.
-		template <typename Tuple SOAGEN_ENABLE_IF(
-			(table_traits::row_constructible_from<Tuple&&> && table_traits::row_constructible_from<Tuple&&>))>
+		template <typename Tuple SOAGEN_ENABLE_IF(table_traits::row_constructible_from<Tuple&&>)>
 		SOAGEN_CPP20_CONSTEXPR
-		spheres& emplace_back(Tuple&& tuple_) //
-			noexcept(table_traits::emplace_back_is_nothrow<table_type&, Tuple&&>) SOAGEN_REQUIRES(
-				table_traits::row_constructible_from<Tuple&&>&& table_traits::row_constructible_from<Tuple&&>) //
+		spheres& emplace_back(Tuple&& tuple_)									 //
+			noexcept(table_traits::emplace_back_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(table_traits::row_constructible_from<Tuple&&>)		 //
 		{
 			table_.emplace_back(static_cast<Tuple&&>(tuple_));
 			return *this;
@@ -1915,8 +1938,8 @@ namespace soagen::examples
 		/// @brief Inserts a new row at an arbitrary position in the table.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::all_move_constructible && table_traits::all_move_assignable)>
+		SOAGEN_HIDDEN(template <bool sfinae = (table_traits::all_move_or_copy_constructible
+											   && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		SOAGEN_ENABLE_IF_T(spheres&, sfinae) insert(size_type index_,
@@ -1924,9 +1947,9 @@ namespace soagen::examples
 													column_traits<1>::param_type center_y,
 													column_traits<2>::param_type center_z,
 													column_traits<3>::param_type radius = 0.5,
-													column_traits<4>::param_type mass	= default_mass) //
-			noexcept(table_traits::insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable) //
+													column_traits<4>::param_type mass	= default_mass)				  //
+			noexcept(table_traits::insert_is_nothrow<table_type>)													  //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(index_,
 						   static_cast<column_traits<0>::param_forward_type>(center_x),
@@ -1940,8 +1963,8 @@ namespace soagen::examples
 		/// @brief Inserts a new row at an arbitrary position in the table.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::all_move_constructible && table_traits::all_move_assignable)>
+		SOAGEN_HIDDEN(template <bool sfinae = (table_traits::all_move_or_copy_constructible
+											   && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		SOAGEN_ENABLE_IF_T(iterator, sfinae) insert(iterator iter_,
@@ -1949,9 +1972,9 @@ namespace soagen::examples
 													column_traits<1>::param_type center_y,
 													column_traits<2>::param_type center_z,
 													column_traits<3>::param_type radius = 0.5,
-													column_traits<4>::param_type mass	= default_mass) //
-			noexcept(table_traits::insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable) //
+													column_traits<4>::param_type mass	= default_mass)				  //
+			noexcept(table_traits::insert_is_nothrow<table_type>)													  //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::param_forward_type>(center_x),
@@ -1965,8 +1988,8 @@ namespace soagen::examples
 		/// @brief Inserts a new row at an arbitrary position in the table.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::all_move_constructible && table_traits::all_move_assignable)>
+		SOAGEN_HIDDEN(template <bool sfinae = (table_traits::all_move_or_copy_constructible
+											   && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		SOAGEN_ENABLE_IF_T(const_iterator, sfinae) insert(const_iterator iter_,
@@ -1974,9 +1997,9 @@ namespace soagen::examples
 														  column_traits<1>::param_type center_y,
 														  column_traits<2>::param_type center_z,
 														  column_traits<3>::param_type radius = 0.5,
-														  column_traits<4>::param_type mass	  = default_mass) //
-			noexcept(table_traits::insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable) //
+														  column_traits<4>::param_type mass	  = default_mass)			  //
+			noexcept(table_traits::insert_is_nothrow<table_type>)													  //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::param_forward_type>(center_x),
@@ -1991,8 +2014,8 @@ namespace soagen::examples
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
 		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::rvalue_type_list_is_distinct && table_traits::all_move_constructible
-									 && table_traits::all_move_assignable)>
+			template <bool sfinae = (table_traits::rvalues_are_distinct && table_traits::all_move_or_copy_constructible
+									 && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		spheres& insert(SOAGEN_ENABLE_IF_T(size_type, sfinae) index_,
@@ -2001,9 +2024,9 @@ namespace soagen::examples
 						column_traits<2>::rvalue_type center_z,
 						column_traits<3>::rvalue_type radius = 0.5,
 						column_traits<4>::rvalue_type mass	 = default_mass) //
-			noexcept(table_traits::rvalue_insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable) //
+			noexcept(table_traits::rvalue_insert_is_nothrow<table_type>)   //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct&& table_traits::all_move_or_copy_constructible&&
+								table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(index_,
 						   static_cast<column_traits<0>::rvalue_forward_type>(center_x),
@@ -2018,8 +2041,8 @@ namespace soagen::examples
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
 		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::rvalue_type_list_is_distinct && table_traits::all_move_constructible
-									 && table_traits::all_move_assignable)>
+			template <bool sfinae = (table_traits::rvalues_are_distinct && table_traits::all_move_or_copy_constructible
+									 && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		iterator insert(SOAGEN_ENABLE_IF_T(iterator, sfinae) iter_,
@@ -2028,9 +2051,9 @@ namespace soagen::examples
 						column_traits<2>::rvalue_type center_z,
 						column_traits<3>::rvalue_type radius = 0.5,
 						column_traits<4>::rvalue_type mass	 = default_mass) //
-			noexcept(table_traits::rvalue_insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable) //
+			noexcept(table_traits::rvalue_insert_is_nothrow<table_type>)   //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct&& table_traits::all_move_or_copy_constructible&&
+								table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::rvalue_forward_type>(center_x),
@@ -2045,8 +2068,8 @@ namespace soagen::examples
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
 		SOAGEN_HIDDEN(
-			template <bool sfinae = (table_traits::rvalue_type_list_is_distinct && table_traits::all_move_constructible
-									 && table_traits::all_move_assignable)>
+			template <bool sfinae = (table_traits::rvalues_are_distinct && table_traits::all_move_or_copy_constructible
+									 && table_traits::all_move_or_copy_assignable)>
 		)
 		SOAGEN_CPP20_CONSTEXPR
 		const_iterator insert(SOAGEN_ENABLE_IF_T(const_iterator, sfinae) iter_,
@@ -2055,9 +2078,9 @@ namespace soagen::examples
 							  column_traits<2>::rvalue_type center_z,
 							  column_traits<3>::rvalue_type radius = 0.5,
 							  column_traits<4>::rvalue_type mass   = default_mass) //
-			noexcept(table_traits::rvalue_insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable) //
+			noexcept(table_traits::rvalue_insert_is_nothrow<table_type>)		 //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct&& table_traits::all_move_or_copy_constructible&&
+								table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::rvalue_forward_type>(center_x),
@@ -2076,7 +2099,7 @@ namespace soagen::examples
 				  typename CenterZ,
 				  typename Radius = column_traits<3>::default_emplace_type,
 				  typename Mass	  = column_traits<4>::default_emplace_type SOAGEN_ENABLE_IF(
-						(table_traits::all_move_constructible && table_traits::all_move_assignable
+						(table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable
 						 && table_traits::row_constructible_from<CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>))>
 		SOAGEN_CPP20_CONSTEXPR
 		spheres& emplace(size_type index_,
@@ -2084,11 +2107,11 @@ namespace soagen::examples
 						 CenterY&& center_y,
 						 CenterZ&& center_z,
 						 Radius&& radius = 0.5,
-						 Mass&& mass	 = default_mass) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>)
-				SOAGEN_REQUIRES(
-					table_traits::all_move_constructible&& table_traits::all_move_assignable&&
-						table_traits::row_constructible_from<CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>) //
+						 Mass&& mass	 = default_mass)																  //
+			noexcept(table_traits::emplace_is_nothrow<table_type, CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable&&
+					table_traits::row_constructible_from<CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>) //
 		{
 			table_.emplace(index_,
 						   static_cast<CenterX&&>(center_x),
@@ -2107,7 +2130,7 @@ namespace soagen::examples
 				  typename CenterZ,
 				  typename Radius = column_traits<3>::default_emplace_type,
 				  typename Mass	  = column_traits<4>::default_emplace_type SOAGEN_ENABLE_IF(
-						(table_traits::all_move_constructible && table_traits::all_move_assignable
+						(table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable
 						 && table_traits::row_constructible_from<CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>))>
 		SOAGEN_CPP20_CONSTEXPR
 		iterator emplace(iterator iter_,
@@ -2115,11 +2138,11 @@ namespace soagen::examples
 						 CenterY&& center_y,
 						 CenterZ&& center_z,
 						 Radius&& radius = 0.5,
-						 Mass&& mass	 = default_mass) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>)
-				SOAGEN_REQUIRES(
-					table_traits::all_move_constructible&& table_traits::all_move_assignable&&
-						table_traits::row_constructible_from<CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>) //
+						 Mass&& mass	 = default_mass)																  //
+			noexcept(table_traits::emplace_is_nothrow<table_type, CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable&&
+					table_traits::row_constructible_from<CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<CenterX&&>(center_x),
@@ -2138,7 +2161,7 @@ namespace soagen::examples
 				  typename CenterZ,
 				  typename Radius = column_traits<3>::default_emplace_type,
 				  typename Mass	  = column_traits<4>::default_emplace_type SOAGEN_ENABLE_IF(
-						(table_traits::all_move_constructible && table_traits::all_move_assignable
+						(table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable
 						 && table_traits::row_constructible_from<CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>))>
 		SOAGEN_CPP20_CONSTEXPR
 		const_iterator emplace(const_iterator iter_,
@@ -2146,11 +2169,11 @@ namespace soagen::examples
 							   CenterY&& center_y,
 							   CenterZ&& center_z,
 							   Radius&& radius = 0.5,
-							   Mass&& mass	   = default_mass) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>)
-				SOAGEN_REQUIRES(
-					table_traits::all_move_constructible&& table_traits::all_move_assignable&&
-						table_traits::row_constructible_from<CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>) //
+							   Mass&& mass	   = default_mass)															  //
+			noexcept(table_traits::emplace_is_nothrow<table_type, CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable&&
+					table_traits::row_constructible_from<CenterX&&, CenterY&&, CenterZ&&, Radius&&, Mass&&>) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<CenterX&&>(center_x),
@@ -2164,14 +2187,15 @@ namespace soagen::examples
 		/// @brief Constructs a new row directly in-place at an arbitrary position in the table by unpacking a tuple-like object.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		template <typename Tuple SOAGEN_ENABLE_IF(
-			(table_traits::row_constructible_from<Tuple&&> && table_traits::all_move_constructible
-			 && table_traits::all_move_assignable && table_traits::row_constructible_from<size_type, Tuple&&>))>
+		template <typename Tuple SOAGEN_ENABLE_IF((table_traits::row_constructible_from<Tuple&&>
+												   && table_traits::all_move_or_copy_constructible
+												   && table_traits::all_move_or_copy_assignable))>
 		SOAGEN_CPP20_CONSTEXPR
-		spheres& emplace(size_type index_, Tuple&& tuple_) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Tuple&&>) SOAGEN_REQUIRES(
-				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_constructible&&
-					table_traits::all_move_assignable&& table_traits::row_constructible_from<size_type, Tuple&&>) //
+		spheres& emplace(size_type index_, Tuple&& tuple_)					//
+			noexcept(table_traits::emplace_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_or_copy_constructible&&
+					table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(index_, static_cast<Tuple&&>(tuple_));
 			return *this;
@@ -2180,14 +2204,15 @@ namespace soagen::examples
 		/// @brief Constructs a new row directly in-place at an arbitrary position in the table by unpacking a tuple-like object.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		template <typename Tuple SOAGEN_ENABLE_IF(
-			(table_traits::row_constructible_from<Tuple&&> && table_traits::all_move_constructible
-			 && table_traits::all_move_assignable && table_traits::row_constructible_from<iterator, Tuple&&>))>
+		template <typename Tuple SOAGEN_ENABLE_IF((table_traits::row_constructible_from<Tuple&&>
+												   && table_traits::all_move_or_copy_constructible
+												   && table_traits::all_move_or_copy_assignable))>
 		SOAGEN_CPP20_CONSTEXPR
-		iterator emplace(iterator iter_, Tuple&& tuple_) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Tuple&&>) SOAGEN_REQUIRES(
-				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_constructible&&
-					table_traits::all_move_assignable&& table_traits::row_constructible_from<iterator, Tuple&&>) //
+		iterator emplace(iterator iter_, Tuple&& tuple_)					//
+			noexcept(table_traits::emplace_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_or_copy_constructible&&
+					table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_), static_cast<Tuple&&>(tuple_));
 			return iter_;
@@ -2196,15 +2221,15 @@ namespace soagen::examples
 		/// @brief Constructs a new row directly in-place at an arbitrary position in the table by unpacking a tuple-like object.
 		///
 		/// @availability This overload is only available when all the column types are move-constructible and move-assignable.
-		template <typename Tuple SOAGEN_ENABLE_IF(
-			(table_traits::row_constructible_from<Tuple&&> && table_traits::all_move_constructible
-			 && table_traits::all_move_assignable && table_traits::row_constructible_from<const_iterator, Tuple&&>))>
+		template <typename Tuple SOAGEN_ENABLE_IF((table_traits::row_constructible_from<Tuple&&>
+												   && table_traits::all_move_or_copy_constructible
+												   && table_traits::all_move_or_copy_assignable))>
 		SOAGEN_CPP20_CONSTEXPR
-		const_iterator emplace(const_iterator iter_, Tuple&& tuple_) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Tuple&&>)
-				SOAGEN_REQUIRES(table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable&&
-										table_traits::row_constructible_from<const_iterator, Tuple&&>) //
+		const_iterator emplace(const_iterator iter_, Tuple&& tuple_)		//
+			noexcept(table_traits::emplace_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_or_copy_constructible&&
+					table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_), static_cast<Tuple&&>(tuple_));
 			return iter_;
diff --git a/meson.build b/meson.build
index c1fa1be..8d15756 100644
--- a/meson.build
+++ b/meson.build
@@ -6,7 +6,7 @@
 project(
 	'soagen',
 	'cpp',
-	version : '0.1.1',
+	version : '0.7.0',
 	meson_version : '>=0.60.0',
 	license : 'MIT',
 	default_options : [ 'cpp_std=c++17', 'b_ndebug=if-release', 'buildtype=release' ]
diff --git a/src/soagen/header_file.py b/src/soagen/header_file.py
index 97f842c..f28e59f 100644
--- a/src/soagen/header_file.py
+++ b/src/soagen/header_file.py
@@ -270,6 +270,11 @@ def write(self, o: Writer):
                         #endif
                         '''
                         )
+                o()
+                for struct in self.structs:
+                    struct.write_impl_namespace(o)
+                o()
+                with Namespace(o, 'soagen::detail'):
                     for struct in self.structs:
                         struct.write_soagen_detail_specializations(o)
 
diff --git a/src/soagen/hpp/column_traits.hpp b/src/soagen/hpp/column_traits.hpp
index e3fa0f1..1fde2cf 100644
--- a/src/soagen/hpp/column_traits.hpp
+++ b/src/soagen/hpp/column_traits.hpp
@@ -525,6 +525,52 @@ namespace soagen::detail
 								  source_buffer + source_index * sizeof(storage_type));
 		}
 
+		//--- move-or-copy-construction (whichever is possible) --------------------------------------------------------
+
+		static constexpr bool is_move_or_copy_constructible = is_move_constructible || is_copy_constructible;
+
+		static constexpr bool is_nothrow_move_or_copy_constructible =
+			is_move_constructible ? is_nothrow_move_constructible : is_nothrow_copy_constructible;
+
+		static constexpr bool is_trivially_move_or_copy_constructible =
+			is_move_constructible ? is_trivially_move_constructible : is_trivially_copy_constructible;
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = is_move_or_copy_constructible)
+		SOAGEN_ATTR(nonnull)
+		SOAGEN_CPP20_CONSTEXPR
+		static storage_type& move_or_copy_construct(std::byte* destination, std::byte* source) //
+			noexcept(is_nothrow_move_or_copy_constructible)
+		{
+			SOAGEN_ASSUME(destination != nullptr);
+			SOAGEN_ASSUME(source != nullptr);
+			SOAGEN_ASSUME(destination != source);
+
+			if constexpr (is_move_constructible)
+			{
+				return move_construct(destination, source);
+			}
+			else
+			{
+				return copy_construct(destination, source);
+			}
+		}
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = is_move_or_copy_constructible)
+		SOAGEN_ATTR(nonnull)
+		SOAGEN_CPP20_CONSTEXPR
+		static storage_type& move_or_copy_construct(std::byte* dest_buffer,
+													size_t dest_index,
+													std::byte* source_buffer,
+													size_t source_index) //
+			noexcept(is_nothrow_move_or_copy_constructible)
+		{
+			SOAGEN_ASSUME(dest_buffer != nullptr);
+			SOAGEN_ASSUME(source_buffer != nullptr);
+
+			return move_or_copy_construct(dest_buffer + dest_index * sizeof(storage_type),
+										  source_buffer + source_index * sizeof(storage_type));
+		}
+
 		//--- destruction ----------------------------------------------------------------------------------------------
 
 		SOAGEN_ATTR(nonnull)
@@ -686,6 +732,52 @@ namespace soagen::detail
 							   source_buffer + source_index * sizeof(storage_type));
 		}
 
+		//--- move-or-copy-assignment (whichever is possible) --------------------------------------------------------
+
+		static constexpr bool is_move_or_copy_assignable = is_move_assignable || is_copy_assignable;
+
+		static constexpr bool is_nothrow_move_or_copy_assignable =
+			is_move_assignable ? is_nothrow_move_assignable : is_nothrow_copy_assignable;
+
+		static constexpr bool is_trivially_move_or_copy_assignable =
+			is_move_assignable ? is_trivially_move_assignable : is_trivially_copy_assignable;
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = is_move_or_copy_assignable)
+		SOAGEN_ATTR(nonnull)
+		SOAGEN_CPP20_CONSTEXPR
+		static storage_type& move_or_copy_assign(std::byte* destination, std::byte* source) //
+			noexcept(is_nothrow_move_or_copy_assignable)
+		{
+			SOAGEN_ASSUME(destination != nullptr);
+			SOAGEN_ASSUME(source != nullptr);
+			SOAGEN_ASSUME(destination != source);
+
+			if constexpr (is_move_assignable)
+			{
+				return move_assign(destination, source);
+			}
+			else
+			{
+				return copy_assign(destination, source);
+			}
+		}
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = is_move_or_copy_assignable)
+		SOAGEN_ATTR(nonnull)
+		SOAGEN_CPP20_CONSTEXPR
+		static storage_type& move_or_copy_assign(std::byte* dest_buffer,
+												 size_t dest_index,
+												 std::byte* source_buffer,
+												 size_t source_index) //
+			noexcept(is_nothrow_move_or_copy_assignable)
+		{
+			SOAGEN_ASSUME(dest_buffer != nullptr);
+			SOAGEN_ASSUME(source_buffer != nullptr);
+
+			return move_or_copy_assign(dest_buffer + dest_index * sizeof(storage_type),
+									   source_buffer + source_index * sizeof(storage_type));
+		}
+
 		//--- swap -----------------------------------------------------------------------------------------------------
 
 		static constexpr bool is_trivially_swappable =
@@ -696,12 +788,13 @@ namespace soagen::detail
 
 		static constexpr bool is_swappable = is_trivially_swappable //
 										  || std::is_swappable_v<storage_type>
-										  || (is_move_constructible && is_move_assignable);
+										  || (is_move_or_copy_constructible && is_move_or_copy_assignable);
 
 		static constexpr bool is_nothrow_swappable =
 			is_trivially_swappable
-			|| (std::is_swappable_v<storage_type> ? std::is_nothrow_swappable_v<storage_type>
-												  : (is_nothrow_move_constructible && is_nothrow_move_assignable));
+			|| (std::is_swappable_v<storage_type>
+					? std::is_nothrow_swappable_v<storage_type>
+					: (is_nothrow_move_or_copy_constructible && is_nothrow_move_or_copy_assignable));
 
 		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = is_swappable)
 		SOAGEN_ATTR(nonnull)
@@ -715,10 +808,10 @@ namespace soagen::detail
 
 			if constexpr (is_trivially_swappable)
 			{
-				alignas(storage_type) std::byte buf[sizeof(storage_type)];
-				std::memcpy(soagen_aligned_storage(buf), soagen_aligned_storage(lhs), sizeof(storage_type));
+				alignas(storage_type) std::byte temp[sizeof(storage_type)];
+				std::memcpy(soagen_aligned_storage(temp), soagen_aligned_storage(lhs), sizeof(storage_type));
 				std::memcpy(soagen_aligned_storage(lhs), soagen_aligned_storage(rhs), sizeof(storage_type));
-				std::memcpy(soagen_aligned_storage(rhs), soagen_aligned_storage(buf), sizeof(storage_type));
+				std::memcpy(soagen_aligned_storage(rhs), soagen_aligned_storage(temp), sizeof(storage_type));
 			}
 			else if constexpr (std::is_swappable_v<storage_type>)
 			{
@@ -727,11 +820,35 @@ namespace soagen::detail
 			}
 			else
 			{
-				static_assert(is_move_constructible && is_move_assignable);
+				static_assert(is_move_or_copy_constructible && is_move_or_copy_assignable);
 
-				storage_type temp(static_cast<storage_type&&>(get(lhs)));
-				move_assign(lhs, rhs);
-				move_assign(rhs, &temp);
+				alignas(storage_type) std::byte temp[sizeof(storage_type)];
+
+				if constexpr ((is_nothrow_move_or_copy_constructible && is_nothrow_move_or_copy_assignable)
+							  || std::is_trivially_destructible_v<storage_type>)
+				{
+					move_or_copy_construct(soagen_aligned_storage(temp), lhs);
+					move_or_copy_assign(lhs, rhs);
+					move_or_copy_assign(rhs, soagen_aligned_storage(temp));
+					destruct(temp);
+				}
+				else
+				{
+					bool needs_destruct = false;
+					try
+					{
+						move_or_copy_construct(soagen_aligned_storage(temp), lhs);
+						needs_destruct = true;
+						move_or_copy_assign(lhs, rhs);
+						move_or_copy_assign(rhs, soagen_aligned_storage(temp));
+					}
+					catch (...)
+					{
+						if (needs_destruct)
+							destruct(temp);
+						throw;
+					}
+				}
 			}
 		}
 
diff --git a/src/soagen/hpp/core.hpp b/src/soagen/hpp/core.hpp
index 86b3576..28a5b65 100644
--- a/src/soagen/hpp/core.hpp
+++ b/src/soagen/hpp/core.hpp
@@ -285,6 +285,17 @@ namespace soagen
 		template <typename T>
 		using has_data_member_ = is_detected_<has_data_member_impl_, T>;
 
+		template <typename T, typename Pos, typename... Args>
+		using has_emplace_member_impl_ =
+			decltype(std::declval<T&>().emplace(std::declval<Pos>(), std::declval<Args>()...));
+		template <typename T, typename Pos, typename... Args>
+		using has_emplace_member_ = is_detected_<has_emplace_member_impl_, Pos, Args...>;
+
+		template <typename T, typename... Args>
+		using has_emplace_back_member_impl_ = decltype(std::declval<T&>().emplace_back(std::declval<Args>()...));
+		template <typename T, typename... Args>
+		using has_emplace_back_member_ = is_detected_<has_emplace_back_member_impl_, Args...>;
+
 		template <typename T, typename U>
 		using is_equality_comparable_impl_ = decltype(std::declval<const std::remove_reference_t<T>&>()
 													  == std::declval<const std::remove_reference_t<U>&>());
@@ -324,6 +335,16 @@ namespace soagen
 	inline constexpr bool has_data_member =
 		POXY_IMPLEMENTATION_DETAIL(std::conjunction<detail::has_data_member_<T>...>::value);
 
+	/// @brief	True if `T` has an `emplace(Pos, Args...)` member.
+	template <typename T, typename Pos, typename... Args>
+	inline constexpr bool has_emplace_member =
+		POXY_IMPLEMENTATION_DETAIL(detail::has_emplace_member_<T, Pos, Args...>::value);
+
+	/// @brief	True if `T` has an `emplace_back(Args...)` member.
+	template <typename T, typename... Args>
+	inline constexpr bool has_emplace_back_member =
+		POXY_IMPLEMENTATION_DETAIL(detail::has_emplace_back_member_<T, Args...>::value);
+
 	/// @brief	True if `T` and `U` meet the `EqualityComparable` named requirement.
 	template <typename T, typename U = T>
 	inline constexpr bool is_equality_comparable =
@@ -375,6 +396,22 @@ namespace soagen
 		struct has_nothrow_data_member_<T, false> : std::false_type
 		{};
 
+		template <bool /* has_emplace_member<T, Pos, Args> */, typename T, typename Pos, typename... Args>
+		struct has_nothrow_emplace_member_
+			: std::bool_constant<noexcept(std::declval<T&>().emplace(std::declval<Pos>(), std::declval<Args>()...))>
+		{};
+		template <typename T, typename Pos, typename... Args>
+		struct has_nothrow_emplace_member_<false, T, Pos, Args...> : std::false_type
+		{};
+
+		template <bool /* has_emplace_back_member<T, Args> */, typename T, typename... Args>
+		struct has_nothrow_emplace_back_member_
+			: std::bool_constant<noexcept(std::declval<T&>().emplace_back(std::declval<Args>()...))>
+		{};
+		template <typename T, typename... Args>
+		struct has_nothrow_emplace_back_member_<false, T, Args...> : std::false_type
+		{};
+
 		template <typename T, typename U = T, bool = is_equality_comparable<T, U>>
 		struct is_nothrow_equality_comparable_
 			: std::bool_constant<noexcept(std::declval<const std::remove_reference_t<T>&>()
@@ -420,6 +457,16 @@ namespace soagen
 	inline constexpr bool has_nothrow_data_member =
 		POXY_IMPLEMENTATION_DETAIL(std::conjunction<detail::has_nothrow_data_member_<T>...>::value);
 
+	/// @brief	True if `T` has a non-throwing `emplace(Pos, Args...)` member.
+	template <typename T, typename Pos, typename... Args>
+	inline constexpr bool has_nothrow_emplace_member = POXY_IMPLEMENTATION_DETAIL(
+		detail::has_nothrow_emplace_member_<has_emplace_member<T, Pos, Args...>, T, Pos, Args...>::value);
+
+	/// @brief	True if `T` has a non-throwing `emplace_back(Args...)` member.
+	template <typename T, typename... Args>
+	inline constexpr bool has_nothrow_emplace_back_member = POXY_IMPLEMENTATION_DETAIL(
+		detail::has_nothrow_emplace_back_member_<has_emplace_back_member<T, Args...>, T, Args...>::value);
+
 	/// @brief	True if `T` and `U` meet the `EqualityComparable` named requirement without throwing.
 	template <typename T, typename U = T>
 	inline constexpr bool is_nothrow_equality_comparable =
@@ -432,22 +479,23 @@ namespace soagen
 
 #if !SOAGEN_DOXYGEN && SOAGEN_HAS_BUILTIN(__type_pack_element)
 
-	template <size_t I, typename... T>
-	using type_at_index = __type_pack_element<I, T...>;
+	template <auto I, typename... T>
+	using type_at_index = __type_pack_element<static_cast<size_t>(I), T...>;
 
 #else
 
 	/// @cond
 	namespace detail
 	{
+		template <size_t, typename...>
+		struct type_at_index_;
+
 		template <size_t I, typename T, typename... U>
-		struct type_at_index_impl
-		{
-			using type = typename type_at_index_impl<I - 1, U...>::type;
-		};
+		struct type_at_index_<I, T, U...> : type_at_index_<I - 1, U...>
+		{};
 
 		template <typename T, typename... U>
-		struct type_at_index_impl<0, T, U...>
+		struct type_at_index_<0, T, U...>
 		{
 			using type = T;
 		};
@@ -455,8 +503,9 @@ namespace soagen
 	/// @endcond
 
 	/// @brief Gets the type `T` at index `I` in the parameter pack.
-	template <size_t I, typename... T>
-	using type_at_index = POXY_IMPLEMENTATION_DETAIL(typename detail::type_at_index_impl<I, T...>::type);
+	template <auto I, typename... T>
+	using type_at_index =
+		POXY_IMPLEMENTATION_DETAIL(typename detail::type_at_index_<static_cast<size_t>(I), T...>::type);
 
 #endif
 
diff --git a/src/soagen/hpp/iterator.hpp b/src/soagen/hpp/iterator.hpp
index b70dc4b..3ac3dff 100644
--- a/src/soagen/hpp/iterator.hpp
+++ b/src/soagen/hpp/iterator.hpp
@@ -116,8 +116,8 @@ namespace soagen
 
 		/// @brief Constructs an iterator to some row of a SoA container.
 		SOAGEN_NODISCARD_CTOR
-		constexpr iterator(soa_ref soa, difference_type pos) noexcept //
-			: base{ const_cast<soa_type*>(&soa), pos }
+		constexpr iterator(soa_ref src, difference_type pos) noexcept //
+			: base{ const_cast<soa_type*>(&src), pos }
 		{}
 
 		/// @name Incrementing
diff --git a/src/soagen/hpp/single/.clang-format b/src/soagen/hpp/single/.clang-format
new file mode 100644
index 0000000..e384528
--- /dev/null
+++ b/src/soagen/hpp/single/.clang-format
@@ -0,0 +1 @@
+DisableFormat: true
diff --git a/src/soagen/hpp/single/soagen.hpp b/src/soagen/hpp/single/soagen.hpp
index a6a17b6..5f66e39 100644
--- a/src/soagen/hpp/single/soagen.hpp
+++ b/src/soagen/hpp/single/soagen.hpp
@@ -1019,7 +1019,7 @@ SOAGEN_ENABLE_WARNINGS;
 #endif
 
 #if !defined(__POXY__) && !defined(POXY_IMPLEMENTATION_DETAIL)
-	#define POXY_IMPLEMENTATION_DETAIL(...) __VA_ARGS__
+	#define ...) __VA_ARGS__
 #endif
 
 //********  generated/functions.hpp  ***********************************************************************************
@@ -1070,7 +1070,7 @@ namespace soagen
 
 #elif SOAGEN_CLANG >= 9 || SOAGEN_GCC >= 9 || SOAGEN_MSVC >= 1925 || SOAGEN_HAS_BUILTIN(is_constant_evaluated)
 
-		return __builtin_is_constant_evaluated();
+		return __builtin_is_constant_evaluated(;
 
 #elif defined(__cpp_lib_is_constant_evaluated) && __cpp_lib_is_constant_evaluated >= 201811
 
@@ -1401,27 +1401,27 @@ namespace soagen
 
 	template <typename T>
 	inline constexpr bool is_implicit_lifetime_type =
-		POXY_IMPLEMENTATION_DETAIL(detail::is_implicit_lifetime_type_<T>::value);
+		detail::is_implicit_lifetime_type_<T>::value;
 
 	template <typename T, typename CopyFrom>
-	using copy_cv = POXY_IMPLEMENTATION_DETAIL(typename detail::copy_cv_<std::remove_cv_t<T>, CopyFrom>::type);
+	using copy_cv = typename detail::copy_cv_<std::remove_cv_t<T>, CopyFrom>::type;
 
 	template <typename T, typename CopyFrom>
-	using copy_ref = POXY_IMPLEMENTATION_DETAIL(typename detail::copy_ref_<std::remove_reference_t<T>, CopyFrom>::type);
+	using copy_ref = typename detail::copy_ref_<std::remove_reference_t<T>, CopyFrom>::type;
 
 	template <typename T, typename CopyFrom>
 	using copy_cvref =
-		POXY_IMPLEMENTATION_DETAIL(copy_ref<copy_cv<remove_cvref<T>, std::remove_reference_t<CopyFrom>>, CopyFrom>);
+		copy_ref<copy_cv<remove_cvref<T>, std::remove_reference_t<CopyFrom>>, CopyFrom>;
 
 	template <typename T>
-	using remove_lvalue_ref = POXY_IMPLEMENTATION_DETAIL(typename detail::remove_lvalue_ref_<T>::type);
+	using remove_lvalue_ref = typename detail::remove_lvalue_ref_<T>::type;
 
 	template <auto Value>
 	using index_constant = std::integral_constant<size_t, static_cast<size_t>(Value)>;
 
 	template <typename T>
-	using forward_type = POXY_IMPLEMENTATION_DETAIL(
-		std::conditional_t<std::is_lvalue_reference_v<T>, T, std::add_rvalue_reference_t<T>>);
+	using forward_type =
+		std::conditional_t<std::is_lvalue_reference_v<T>, T, std::add_rvalue_reference_t<T>>;
 
 #ifdef SOAGEN_COLUMN_SPAN_TYPE
 
@@ -1457,7 +1457,7 @@ namespace soagen
 	}
 
 	template <template <typename...> typename Trait, typename... Args>
-	inline constexpr auto is_detected = POXY_IMPLEMENTATION_DETAIL(detail::is_detected_<Trait, Args...>::value);
+	inline constexpr auto is_detected = detail::is_detected_<Trait, Args...>::value;
 
 	namespace detail
 	{
@@ -1487,6 +1487,17 @@ namespace soagen
 		template <typename T>
 		using has_data_member_ = is_detected_<has_data_member_impl_, T>;
 
+		template <typename T, typename Pos, typename... Args>
+		using has_emplace_member_impl_ =
+			decltype(std::declval<T&>().emplace(std::declval<Pos>(), std::declval<Args>()...));
+		template <typename T, typename Pos, typename... Args>
+		using has_emplace_member_ = is_detected_<has_emplace_member_impl_, Pos, Args...>;
+
+		template <typename T, typename... Args>
+		using has_emplace_back_member_impl_ = decltype(std::declval<T&>().emplace_back(std::declval<Args>()...));
+		template <typename T, typename... Args>
+		using has_emplace_back_member_ = is_detected_<has_emplace_back_member_impl_, Args...>;
+
 		template <typename T, typename U>
 		using is_equality_comparable_impl_ = decltype(std::declval<const std::remove_reference_t<T>&>()
 													  == std::declval<const std::remove_reference_t<U>&>());
@@ -1502,31 +1513,39 @@ namespace soagen
 
 	template <typename... T>
 	inline constexpr bool has_swap_member =
-		POXY_IMPLEMENTATION_DETAIL(std::conjunction<detail::has_swap_member_<T>...>::value);
+		std::conjunction<detail::has_swap_member_<T>...>::value;
 
 	template <typename... T>
 	inline constexpr bool has_resize_member =
-		POXY_IMPLEMENTATION_DETAIL(std::conjunction<detail::has_resize_member_<T, size_t>...>::value);
+		std::conjunction<detail::has_resize_member_<T, size_t>...>::value;
 
 	template <typename... T>
 	inline constexpr bool has_erase_member =
-		POXY_IMPLEMENTATION_DETAIL(std::conjunction<detail::has_erase_member_<T, size_t>...>::value);
+		std::conjunction<detail::has_erase_member_<T, size_t>...>::value;
 
 	template <typename... T>
 	inline constexpr bool has_unordered_erase_member =
-		POXY_IMPLEMENTATION_DETAIL(std::conjunction<detail::has_unordered_erase_member_<T, size_t>...>::value);
+		std::conjunction<detail::has_unordered_erase_member_<T, size_t>...>::value;
 
 	template <typename... T>
 	inline constexpr bool has_data_member =
-		POXY_IMPLEMENTATION_DETAIL(std::conjunction<detail::has_data_member_<T>...>::value);
+		std::conjunction<detail::has_data_member_<T>...>::value;
+
+	template <typename T, typename Pos, typename... Args>
+	inline constexpr bool has_emplace_member =
+		detail::has_emplace_member_<T, Pos, Args...>::value;
+
+	template <typename T, typename... Args>
+	inline constexpr bool has_emplace_back_member =
+		detail::has_emplace_back_member_<T, Args...>::value;
 
 	template <typename T, typename U = T>
 	inline constexpr bool is_equality_comparable =
-		POXY_IMPLEMENTATION_DETAIL(detail::is_equality_comparable_<T, U>::value);
+		detail::is_equality_comparable_<T, U>::value;
 
 	template <typename T, typename U = T>
 	inline constexpr bool is_less_than_comparable =
-		POXY_IMPLEMENTATION_DETAIL(detail::is_less_than_comparable_<T, U>::value);
+		detail::is_less_than_comparable_<T, U>::value;
 
 	namespace detail
 	{
@@ -1568,6 +1587,22 @@ namespace soagen
 		struct has_nothrow_data_member_<T, false> : std::false_type
 		{};
 
+		template <bool /* has_emplace_member<T, Pos, Args> */, typename T, typename Pos, typename... Args>
+		struct has_nothrow_emplace_member_
+			: std::bool_constant<noexcept(std::declval<T&>().emplace(std::declval<Pos>(), std::declval<Args>()...))>
+		{};
+		template <typename T, typename Pos, typename... Args>
+		struct has_nothrow_emplace_member_<false, T, Pos, Args...> : std::false_type
+		{};
+
+		template <bool /* has_emplace_back_member<T, Args> */, typename T, typename... Args>
+		struct has_nothrow_emplace_back_member_
+			: std::bool_constant<noexcept(std::declval<T&>().emplace_back(std::declval<Args>()...))>
+		{};
+		template <typename T, typename... Args>
+		struct has_nothrow_emplace_back_member_<false, T, Args...> : std::false_type
+		{};
+
 		template <typename T, typename U = T, bool = is_equality_comparable<T, U>>
 		struct is_nothrow_equality_comparable_
 			: std::bool_constant<noexcept(std::declval<const std::remove_reference_t<T>&>()
@@ -1589,56 +1624,66 @@ namespace soagen
 
 	template <typename... T>
 	inline constexpr bool has_nothrow_swap_member =
-		POXY_IMPLEMENTATION_DETAIL(std::conjunction<detail::has_nothrow_swap_member_<T>...>::value);
+		std::conjunction<detail::has_nothrow_swap_member_<T>...>::value;
 
 	template <typename... T>
 	inline constexpr bool has_nothrow_resize_member =
-		POXY_IMPLEMENTATION_DETAIL(std::conjunction<detail::has_nothrow_resize_member_<T, size_t>...>::value);
+		std::conjunction<detail::has_nothrow_resize_member_<T, size_t>...>::value;
 
 	template <typename... T>
 	inline constexpr bool has_nothrow_erase_member =
-		POXY_IMPLEMENTATION_DETAIL(std::conjunction<detail::has_nothrow_erase_member_<T, size_t>...>::value);
+		std::conjunction<detail::has_nothrow_erase_member_<T, size_t>...>::value;
 
 	template <typename... T>
 	inline constexpr bool has_nothrow_unordered_erase_member =
-		POXY_IMPLEMENTATION_DETAIL(std::conjunction<detail::has_nothrow_unordered_erase_member_<T, size_t>...>::value);
+		std::conjunction<detail::has_nothrow_unordered_erase_member_<T, size_t>...>::value;
 
 	template <typename... T>
 	inline constexpr bool has_nothrow_data_member =
-		POXY_IMPLEMENTATION_DETAIL(std::conjunction<detail::has_nothrow_data_member_<T>...>::value);
+		std::conjunction<detail::has_nothrow_data_member_<T>...>::value;
+
+	template <typename T, typename Pos, typename... Args>
+	inline constexpr bool has_nothrow_emplace_member =
+		detail::has_nothrow_emplace_member_<has_emplace_member<T, Pos, Args...>, T, Pos, Args...>::value;
+
+	template <typename T, typename... Args>
+	inline constexpr bool has_nothrow_emplace_back_member =
+		detail::has_nothrow_emplace_back_member_<has_emplace_back_member<T, Args...>, T, Args...>::value;
 
 	template <typename T, typename U = T>
 	inline constexpr bool is_nothrow_equality_comparable =
-		POXY_IMPLEMENTATION_DETAIL(detail::is_nothrow_equality_comparable_<T, U>::value);
+		detail::is_nothrow_equality_comparable_<T, U>::value;
 
 	template <typename T, typename U = T>
 	inline constexpr bool is_nothrow_less_than_comparable =
-		POXY_IMPLEMENTATION_DETAIL(detail::is_nothrow_less_than_comparable_<T, U>::value);
+		detail::is_nothrow_less_than_comparable_<T, U>::value;
 
 #if !SOAGEN_DOXYGEN && SOAGEN_HAS_BUILTIN(__type_pack_element)
 
-	template <size_t I, typename... T>
-	using type_at_index = __type_pack_element<I, T...>;
+	template <auto I, typename... T>
+	using type_at_index = __type_pack_element<static_cast<size_t>(I), T...>;
 
 #else
 
 	namespace detail
 	{
+		template <size_t, typename...>
+		struct type_at_index_;
+
 		template <size_t I, typename T, typename... U>
-		struct type_at_index_impl
-		{
-			using type = typename type_at_index_impl<I - 1, U...>::type;
-		};
+		struct type_at_index_<I, T, U...> : type_at_index_<I - 1, U...>
+		{};
 
 		template <typename T, typename... U>
-		struct type_at_index_impl<0, T, U...>
+		struct type_at_index_<0, T, U...>
 		{
 			using type = T;
 		};
 	}
 
-	template <size_t I, typename... T>
-	using type_at_index = POXY_IMPLEMENTATION_DETAIL(typename detail::type_at_index_impl<I, T...>::type);
+	template <auto I, typename... T>
+	using type_at_index =
+		typename detail::type_at_index_<static_cast<size_t>(I), T...>::type;
 
 #endif
 
@@ -1678,19 +1723,19 @@ namespace soagen
 	}
 
 	template <typename T>
-	inline constexpr bool is_table = POXY_IMPLEMENTATION_DETAIL(detail::is_table_<std::remove_cv_t<T>>::value);
+	inline constexpr bool is_table = detail::is_table_<std::remove_cv_t<T>>::value;
 
 	template <typename T>
-	inline constexpr bool is_soa = POXY_IMPLEMENTATION_DETAIL(detail::is_soa_<std::remove_cv_t<T>>::value);
+	inline constexpr bool is_soa = detail::is_soa_<std::remove_cv_t<T>>::value;
 
 	template <typename T>
-	inline constexpr bool is_row = POXY_IMPLEMENTATION_DETAIL(detail::is_row_<std::remove_cv_t<T>>::value);
+	inline constexpr bool is_row = detail::is_row_<std::remove_cv_t<T>>::value;
 
 	template <typename T>
-	inline constexpr bool is_span = POXY_IMPLEMENTATION_DETAIL(detail::is_span_<std::remove_cv_t<T>>::value);
+	inline constexpr bool is_span = detail::is_span_<std::remove_cv_t<T>>::value;
 
 	template <typename T>
-	inline constexpr bool is_iterator = POXY_IMPLEMENTATION_DETAIL(detail::is_iterator_<std::remove_cv_t<T>>::value);
+	inline constexpr bool is_iterator = detail::is_iterator_<std::remove_cv_t<T>>::value;
 
 	namespace detail
 	{
@@ -1720,7 +1765,7 @@ namespace soagen
 	}
 
 	template <typename T>
-	using soa_type = POXY_IMPLEMENTATION_DETAIL(remove_cvref<detail::soa_type_cvref<remove_cvref<T>>>);
+	using soa_type = remove_cvref<detail::soa_type_cvref<remove_cvref<T>>>;
 
 	namespace detail
 	{
@@ -1737,10 +1782,10 @@ namespace soagen
 	}
 
 	template <typename T>
-	using table_type = POXY_IMPLEMENTATION_DETAIL(typename detail::table_type_<soa_type<T>>::type);
+	using table_type = typename detail::table_type_<soa_type<T>>::type;
 
 	template <typename A, typename B>
-	inline constexpr bool same_table_type = POXY_IMPLEMENTATION_DETAIL(std::is_same_v<table_type<A>, table_type<B>>);
+	inline constexpr bool same_table_type = std::is_same_v<table_type<A>, table_type<B>>;
 
 	namespace detail
 	{
@@ -1762,21 +1807,21 @@ namespace soagen
 	}
 
 	template <typename T>
-	using table_traits_type = POXY_IMPLEMENTATION_DETAIL(typename detail::table_traits_type_<remove_cvref<T>>::type);
+	using table_traits_type = typename detail::table_traits_type_<remove_cvref<T>>::type;
 
 	template <typename T, auto Column>
-	using value_type = POXY_IMPLEMENTATION_DETAIL(
-		typename table_traits_type<T>::template column<static_cast<size_t>(Column)>::value_type);
+	using value_type =
+		typename table_traits_type<T>::template column<static_cast<size_t>(Column)>::value_type;
 
 	template <typename T, auto Column>
 	using value_ref =
-		POXY_IMPLEMENTATION_DETAIL(copy_ref<					//
+		copy_ref<					//
 								   conditionally_add_volatile<	//
 									   conditionally_add_const< //
 										   value_type<T, Column>,
 										   std::is_const_v<std::remove_reference_t<detail::soa_type_cvref<T>>>>,
 									   std::is_volatile_v<std::remove_reference_t<detail::soa_type_cvref<T>>>>,
-								   coerce_ref<detail::soa_type_cvref<T>>>);
+								   coerce_ref<detail::soa_type_cvref<T>>>;
 
 	namespace detail
 	{
@@ -1798,7 +1843,7 @@ namespace soagen
 	}
 
 	template <typename T>
-	using allocator_type = POXY_IMPLEMENTATION_DETAIL(typename detail::allocator_type_<remove_cvref<T>>::type);
+	using allocator_type = typename detail::allocator_type_<remove_cvref<T>>::type;
 
 	namespace detail
 	{
@@ -1838,8 +1883,8 @@ namespace soagen
 	}
 
 	template <typename T, auto... Columns>
-	using column_indices = POXY_IMPLEMENTATION_DETAIL(
-		typename detail::column_indices_<std::index_sequence<static_cast<size_t>(Columns)...>, remove_cvref<T>>::type);
+	using column_indices =
+		typename detail::column_indices_<std::index_sequence<static_cast<size_t>(Columns)...>, remove_cvref<T>>::type;
 
 	namespace detail
 	{
@@ -1865,10 +1910,10 @@ namespace soagen
 	}
 
 	template <typename T>
-	using span_type = POXY_IMPLEMENTATION_DETAIL(span<remove_lvalue_ref<detail::soa_type_cvref<remove_lvalue_ref<T>>>>);
+	using span_type = span<remove_lvalue_ref<detail::soa_type_cvref<remove_lvalue_ref<T>>>>;
 
 	template <typename T>
-	using const_span_type = POXY_IMPLEMENTATION_DETAIL(detail::add_const_to_first_type_arg<span_type<T>>);
+	using const_span_type = detail::add_const_to_first_type_arg<span_type<T>>;
 
 	namespace detail
 	{
@@ -1890,20 +1935,20 @@ namespace soagen
 	}
 
 	template <typename T, auto... Columns>
-	using row_type = POXY_IMPLEMENTATION_DETAIL(
-		detail::derive_view_type<row, T, std::index_sequence<static_cast<size_t>(Columns)...>>);
+	using row_type =
+		detail::derive_view_type<row, T, std::index_sequence<static_cast<size_t>(Columns)...>>;
 
 	template <typename T, auto... Columns>
 	using const_row_type =
-		POXY_IMPLEMENTATION_DETAIL(detail::add_const_to_first_type_arg<row_type<T, static_cast<size_t>(Columns)...>>);
+		detail::add_const_to_first_type_arg<row_type<T, static_cast<size_t>(Columns)...>>;
 
 	template <typename T, auto... Columns>
-	using iterator_type = POXY_IMPLEMENTATION_DETAIL(
-		detail::derive_view_type<iterator, T, std::index_sequence<static_cast<size_t>(Columns)...>>);
+	using iterator_type =
+		detail::derive_view_type<iterator, T, std::index_sequence<static_cast<size_t>(Columns)...>>;
 
 	template <typename T, auto... Columns>
-	using const_iterator_type = POXY_IMPLEMENTATION_DETAIL(
-		detail::add_const_to_first_type_arg<iterator_type<T, static_cast<size_t>(Columns)...>>);
+	using const_iterator_type =
+		detail::add_const_to_first_type_arg<iterator_type<T, static_cast<size_t>(Columns)...>>;
 
 	namespace detail
 	{
@@ -1947,7 +1992,7 @@ namespace soagen
 	}
 
 	template <typename ValueType>
-	using storage_type = POXY_IMPLEMENTATION_DETAIL(typename detail::storage_type_<ValueType>::type);
+	using storage_type = typename detail::storage_type_<ValueType>::type;
 
 	namespace detail
 	{
@@ -1989,7 +2034,7 @@ namespace soagen
 	}
 
 	template <typename ValueType>
-	using param_type = POXY_IMPLEMENTATION_DETAIL(typename detail::param_type_<ValueType>::type);
+	using param_type = typename detail::param_type_<ValueType>::type;
 
 	namespace detail
 	{
@@ -2011,7 +2056,7 @@ namespace soagen
 	}
 
 	template <typename ParamType>
-	using rvalue_type = POXY_IMPLEMENTATION_DETAIL(typename detail::rvalue_type_<ParamType>::type);
+	using rvalue_type = typename detail::rvalue_type_<ParamType>::type;
 
 	namespace detail
 	{
@@ -2594,7 +2639,7 @@ namespace soagen
 
 	template <typename T>
 
-	inline constexpr bool is_emplacer = POXY_IMPLEMENTATION_DETAIL(detail::is_emplacer_<std::remove_cv_t<T>>::value);
+	inline constexpr bool is_emplacer = detail::is_emplacer_<std::remove_cv_t<T>>::value;
 }
 
 namespace std
@@ -2636,10 +2681,10 @@ namespace soagen
 	}
 
 	template <typename T>
-	inline constexpr bool is_tuple = POXY_IMPLEMENTATION_DETAIL(
+	inline constexpr bool is_tuple =
 		std::conjunction_v<detail::has_tuple_size_<T>,
 						   detail::has_tuple_element_<T>,
-						   std::disjunction<detail::has_tuple_get_member_<T>, detail::has_tuple_get_adl_<T>>>);
+						   std::disjunction<detail::has_tuple_get_member_<T>, detail::has_tuple_get_adl_<T>>>;
 
 	template <size_t I, typename T>
 	SOAGEN_NODISCARD
@@ -2697,7 +2742,7 @@ namespace soagen
 
 	template <typename T, typename Tuple>
 	inline constexpr bool is_constructible_by_unpacking_tuple =
-		POXY_IMPLEMENTATION_DETAIL(detail::is_constructible_by_unpacking_tuple_<T, Tuple>::value);
+		detail::is_constructible_by_unpacking_tuple_<T, Tuple>::value;
 }
 
 //********  column_traits.hpp  *****************************************************************************************
@@ -3217,6 +3262,52 @@ namespace soagen::detail
 								  source_buffer + source_index * sizeof(storage_type));
 		}
 
+		//--- move-or-copy-construction (whichever is possible) --------------------------------------------------------
+
+		static constexpr bool is_move_or_copy_constructible = is_move_constructible || is_copy_constructible;
+
+		static constexpr bool is_nothrow_move_or_copy_constructible =
+			is_move_constructible ? is_nothrow_move_constructible : is_nothrow_copy_constructible;
+
+		static constexpr bool is_trivially_move_or_copy_constructible =
+			is_move_constructible ? is_trivially_move_constructible : is_trivially_copy_constructible;
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = is_move_or_copy_constructible)
+		SOAGEN_ATTR(nonnull)
+		SOAGEN_CPP20_CONSTEXPR
+		static storage_type& move_or_copy_construct(std::byte* destination, std::byte* source) //
+			noexcept(is_nothrow_move_or_copy_constructible)
+		{
+			SOAGEN_ASSUME(destination != nullptr);
+			SOAGEN_ASSUME(source != nullptr);
+			SOAGEN_ASSUME(destination != source);
+
+			if constexpr (is_move_constructible)
+			{
+				return move_construct(destination, source);
+			}
+			else
+			{
+				return copy_construct(destination, source);
+			}
+		}
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = is_move_or_copy_constructible)
+		SOAGEN_ATTR(nonnull)
+		SOAGEN_CPP20_CONSTEXPR
+		static storage_type& move_or_copy_construct(std::byte* dest_buffer,
+													size_t dest_index,
+													std::byte* source_buffer,
+													size_t source_index) //
+			noexcept(is_nothrow_move_or_copy_constructible)
+		{
+			SOAGEN_ASSUME(dest_buffer != nullptr);
+			SOAGEN_ASSUME(source_buffer != nullptr);
+
+			return move_or_copy_construct(dest_buffer + dest_index * sizeof(storage_type),
+										  source_buffer + source_index * sizeof(storage_type));
+		}
+
 		//--- destruction ----------------------------------------------------------------------------------------------
 
 		SOAGEN_ATTR(nonnull)
@@ -3378,6 +3469,52 @@ namespace soagen::detail
 							   source_buffer + source_index * sizeof(storage_type));
 		}
 
+		//--- move-or-copy-assignment (whichever is possible) --------------------------------------------------------
+
+		static constexpr bool is_move_or_copy_assignable = is_move_assignable || is_copy_assignable;
+
+		static constexpr bool is_nothrow_move_or_copy_assignable =
+			is_move_assignable ? is_nothrow_move_assignable : is_nothrow_copy_assignable;
+
+		static constexpr bool is_trivially_move_or_copy_assignable =
+			is_move_assignable ? is_trivially_move_assignable : is_trivially_copy_assignable;
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = is_move_or_copy_assignable)
+		SOAGEN_ATTR(nonnull)
+		SOAGEN_CPP20_CONSTEXPR
+		static storage_type& move_or_copy_assign(std::byte* destination, std::byte* source) //
+			noexcept(is_nothrow_move_or_copy_assignable)
+		{
+			SOAGEN_ASSUME(destination != nullptr);
+			SOAGEN_ASSUME(source != nullptr);
+			SOAGEN_ASSUME(destination != source);
+
+			if constexpr (is_move_assignable)
+			{
+				return move_assign(destination, source);
+			}
+			else
+			{
+				return copy_assign(destination, source);
+			}
+		}
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = is_move_or_copy_assignable)
+		SOAGEN_ATTR(nonnull)
+		SOAGEN_CPP20_CONSTEXPR
+		static storage_type& move_or_copy_assign(std::byte* dest_buffer,
+												 size_t dest_index,
+												 std::byte* source_buffer,
+												 size_t source_index) //
+			noexcept(is_nothrow_move_or_copy_assignable)
+		{
+			SOAGEN_ASSUME(dest_buffer != nullptr);
+			SOAGEN_ASSUME(source_buffer != nullptr);
+
+			return move_or_copy_assign(dest_buffer + dest_index * sizeof(storage_type),
+									   source_buffer + source_index * sizeof(storage_type));
+		}
+
 		//--- swap -----------------------------------------------------------------------------------------------------
 
 		static constexpr bool is_trivially_swappable =
@@ -3388,12 +3525,13 @@ namespace soagen::detail
 
 		static constexpr bool is_swappable = is_trivially_swappable //
 										  || std::is_swappable_v<storage_type>
-										  || (is_move_constructible && is_move_assignable);
+										  || (is_move_or_copy_constructible && is_move_or_copy_assignable);
 
 		static constexpr bool is_nothrow_swappable =
 			is_trivially_swappable
-			|| (std::is_swappable_v<storage_type> ? std::is_nothrow_swappable_v<storage_type>
-												  : (is_nothrow_move_constructible && is_nothrow_move_assignable));
+			|| (std::is_swappable_v<storage_type>
+					? std::is_nothrow_swappable_v<storage_type>
+					: (is_nothrow_move_or_copy_constructible && is_nothrow_move_or_copy_assignable));
 
 		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = is_swappable)
 		SOAGEN_ATTR(nonnull)
@@ -3407,10 +3545,10 @@ namespace soagen::detail
 
 			if constexpr (is_trivially_swappable)
 			{
-				alignas(storage_type) std::byte buf[sizeof(storage_type)];
-				std::memcpy(soagen_aligned_storage(buf), soagen_aligned_storage(lhs), sizeof(storage_type));
+				alignas(storage_type) std::byte temp[sizeof(storage_type)];
+				std::memcpy(soagen_aligned_storage(temp), soagen_aligned_storage(lhs), sizeof(storage_type));
 				std::memcpy(soagen_aligned_storage(lhs), soagen_aligned_storage(rhs), sizeof(storage_type));
-				std::memcpy(soagen_aligned_storage(rhs), soagen_aligned_storage(buf), sizeof(storage_type));
+				std::memcpy(soagen_aligned_storage(rhs), soagen_aligned_storage(temp), sizeof(storage_type));
 			}
 			else if constexpr (std::is_swappable_v<storage_type>)
 			{
@@ -3419,11 +3557,35 @@ namespace soagen::detail
 			}
 			else
 			{
-				static_assert(is_move_constructible && is_move_assignable);
+				static_assert(is_move_or_copy_constructible && is_move_or_copy_assignable);
+
+				alignas(storage_type) std::byte temp[sizeof(storage_type)];
 
-				storage_type temp(static_cast<storage_type&&>(get(lhs)));
-				move_assign(lhs, rhs);
-				move_assign(rhs, &temp);
+				if constexpr ((is_nothrow_move_or_copy_constructible && is_nothrow_move_or_copy_assignable)
+							  || std::is_trivially_destructible_v<storage_type>)
+				{
+					move_or_copy_construct(soagen_aligned_storage(temp), lhs);
+					move_or_copy_assign(lhs, rhs);
+					move_or_copy_assign(rhs, soagen_aligned_storage(temp));
+					destruct(temp);
+				}
+				else
+				{
+					bool needs_destruct = false;
+					try
+					{
+						move_or_copy_construct(soagen_aligned_storage(temp), lhs);
+						needs_destruct = true;
+						move_or_copy_assign(lhs, rhs);
+						move_or_copy_assign(rhs, soagen_aligned_storage(temp));
+					}
+					catch (...)
+					{
+						if (needs_destruct)
+							destruct(temp);
+						throw;
+					}
+				}
 			}
 		}
 
@@ -3596,8 +3758,8 @@ namespace soagen
 
 		using rvalue_forward_type = forward_type<rvalue_type>;
 
-		using default_emplace_type = POXY_IMPLEMENTATION_DETAIL(
-			std::add_lvalue_reference_t<std::add_const_t<std::remove_reference_t<rvalue_type>>>);
+		using default_emplace_type =
+			std::add_lvalue_reference_t<std::add_const_t<std::remove_reference_t<rvalue_type>>>;
 	};
 
 	namespace detail
@@ -3615,7 +3777,7 @@ namespace soagen
 
 	template <typename T>
 	inline constexpr bool is_column_traits =
-		POXY_IMPLEMENTATION_DETAIL(detail::is_column_traits_<std::remove_cv_t<T>>::value);
+		detail::is_column_traits_<std::remove_cv_t<T>>::value;
 }
 
 namespace soagen::detail
@@ -3848,11 +4010,11 @@ namespace soagen
 	}
 
 	template <typename Func, typename... Args>
-	inline constexpr bool is_invocable = POXY_IMPLEMENTATION_DETAIL(detail::is_invocable_<Func, Args...>::value);
+	inline constexpr bool is_invocable = detail::is_invocable_<Func, Args...>::value;
 
 	template <typename Func, typename... Args>
 	inline constexpr bool is_nothrow_invocable =
-		POXY_IMPLEMENTATION_DETAIL(detail::is_invocable_<Func, Args...>::is_nothrow::value);
+		detail::is_invocable_<Func, Args...>::is_nothrow::value;
 
 	namespace detail
 	{
@@ -3868,11 +4030,11 @@ namespace soagen
 
 	template <size_t I, typename Func, typename Arg>
 	inline constexpr bool is_invocable_with_optional_index =
-		POXY_IMPLEMENTATION_DETAIL(detail::is_invocable_with_optional_index_<I, Func, Arg>::value);
+		detail::is_invocable_with_optional_index_<I, Func, Arg>::value;
 
 	template <size_t I, typename Func, typename Arg>
 	inline constexpr bool is_nothrow_invocable_with_optional_index =
-		POXY_IMPLEMENTATION_DETAIL(detail::is_invocable_with_optional_index_<I, Func, Arg>::is_nothrow::value);
+		detail::is_invocable_with_optional_index_<I, Func, Arg>::is_nothrow::value;
 
 	template <size_t I, typename Func, typename Arg>
 	SOAGEN_ALWAYS_INLINE
@@ -4206,7 +4368,7 @@ namespace soagen::detail
 		using column = type_at_index<static_cast<size_t>(Index), Columns...>;
 
 		template <typename IndexConstant>
-		using column_from_ic = type_at_index<static_cast<size_t>(IndexConstant::value), Columns...>;
+		using column_from_ic = type_at_index<static_cast<size_t>(remove_cvref<IndexConstant>::value), Columns...>;
 
 		template <auto Index>
 		using storage_type = typename column<static_cast<size_t>(Index)>::storage_type;
@@ -4233,14 +4395,6 @@ namespace soagen::detail
 
 		static constexpr bool any_trivially_copyable = (false || ... || Columns::is_trivially_copyable);
 
-		// copy-constructibility
-
-		static constexpr bool all_copy_constructible = (Columns::is_copy_constructible && ...);
-
-		static constexpr bool all_nothrow_copy_constructible = (Columns::is_nothrow_copy_constructible && ...);
-
-		static constexpr bool all_trivially_copy_constructible = (Columns::is_trivially_copy_constructible && ...);
-
 		// move-constructibility
 
 		static constexpr bool all_move_constructible = (Columns::is_move_constructible && ...);
@@ -4249,6 +4403,22 @@ namespace soagen::detail
 
 		static constexpr bool all_trivially_move_constructible = (Columns::is_trivially_move_constructible && ...);
 
+		// move-assignability
+
+		static constexpr bool all_move_assignable = (Columns::is_move_assignable && ...);
+
+		static constexpr bool all_nothrow_move_assignable = (Columns::is_nothrow_move_assignable && ...);
+
+		static constexpr bool all_trivially_move_assignable = (Columns::is_trivially_move_assignable && ...);
+
+		// copy-constructibility
+
+		static constexpr bool all_copy_constructible = (Columns::is_copy_constructible && ...);
+
+		static constexpr bool all_nothrow_copy_constructible = (Columns::is_nothrow_copy_constructible && ...);
+
+		static constexpr bool all_trivially_copy_constructible = (Columns::is_trivially_copy_constructible && ...);
+
 		// copy-assignability
 
 		static constexpr bool all_copy_assignable = (Columns::is_copy_assignable && ...);
@@ -4257,13 +4427,25 @@ namespace soagen::detail
 
 		static constexpr bool all_trivially_copy_assignable = (Columns::is_trivially_copy_assignable && ...);
 
-		// move-assignability
+		// move-or-copy-constructibility
 
-		static constexpr bool all_move_assignable = (Columns::is_move_assignable && ...);
+		static constexpr bool all_move_or_copy_constructible = (Columns::is_move_or_copy_constructible && ...);
 
-		static constexpr bool all_nothrow_move_assignable = (Columns::is_nothrow_move_assignable && ...);
+		static constexpr bool all_nothrow_move_or_copy_constructible =
+			(Columns::is_nothrow_move_or_copy_constructible && ...);
 
-		static constexpr bool all_trivially_move_assignable = (Columns::is_trivially_move_assignable && ...);
+		static constexpr bool all_trivially_move_or_copy_constructible =
+			(Columns::is_trivially_move_or_copy_constructible && ...);
+
+		// move-or-copy-assignability
+
+		static constexpr bool all_move_or_copy_assignable = (Columns::is_move_or_copy_assignable && ...);
+
+		static constexpr bool all_nothrow_move_or_copy_assignable =
+			(Columns::is_nothrow_move_or_copy_assignable && ...);
+
+		static constexpr bool all_trivially_move_or_copy_assignable =
+			(Columns::is_trivially_move_or_copy_assignable && ...);
 
 		// destructibility
 
@@ -4574,11 +4756,13 @@ namespace soagen::detail
 
 					const auto constructor =
 						[&](auto ic, auto&& arg) noexcept(
-							std::is_nothrow_constructible_v<storage_type<decltype(ic)::value>, decltype(arg)&&>)
+							column_from_ic<decltype(ic)>::template is_nothrow_constructible<decltype(arg)>)
 					{
+						static_assert(std::is_reference_v<decltype(arg)>);
+
 						column_from_ic<decltype(ic)>::construct_at(columns[decltype(ic)::value],
 																   index,
-																   static_cast<decltype(arg)&&>(arg));
+																   static_cast<decltype(arg)>(arg));
 
 						constructed_columns++;
 					};
@@ -4622,7 +4806,7 @@ namespace soagen::detail
 				size_t constructed_columns = {};
 
 				const auto constructor =
-					[&](auto ic) noexcept(std::is_nothrow_move_constructible_v<storage_type<decltype(ic)::value>>)
+					[&](auto ic) noexcept(column_from_ic<decltype(ic)>::is_nothrow_move_constructible)
 				{
 					column_from_ic<decltype(ic)>::move_construct(dest[decltype(ic)::value],
 																 dest_index,
@@ -4735,7 +4919,7 @@ namespace soagen::detail
 				size_t constructed_columns = {};
 
 				const auto constructor =
-					[&](auto ic) noexcept(std::is_nothrow_copy_constructible_v<storage_type<decltype(ic)::value>>)
+					[&](auto ic) noexcept(column_from_ic<decltype(ic)>::is_nothrow_copy_constructible)
 				{
 					column_from_ic<decltype(ic)>::copy_construct(dest[decltype(ic)::value],
 																 dest_index,
@@ -4824,6 +5008,119 @@ namespace soagen::detail
 			}
 		}
 
+		//--- move-or-copy-construction (whichever is possible per-column) ---------------------------------------------
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = all_move_or_copy_constructible)
+		SOAGEN_NEVER_INLINE
+		SOAGEN_CPP20_CONSTEXPR
+		static void move_or_copy_construct_row(column_pointers& dest,
+											   size_t dest_index,
+											   column_pointers& source,
+											   size_t source_index) //
+			noexcept(all_nothrow_move_or_copy_constructible)
+		{
+			SOAGEN_ASSUME(&dest != &source || dest_index != source_index);
+
+			if constexpr (all_nothrow_move_or_copy_constructible || all_trivially_destructible)
+			{
+				(column<I>::move_or_copy_construct(dest[I], dest_index, source[I], source_index), ...);
+			}
+			else
+			{
+				// machinery to provide strong-exception guarantee
+
+				size_t constructed_columns = {};
+
+				const auto constructor =
+					[&](auto ic) noexcept(column_from_ic<decltype(ic)>::is_nothrow_move_or_copy_constructible)
+				{
+					column_from_ic<decltype(ic)>::move_or_copy_construct(dest[decltype(ic)::value],
+																		 dest_index,
+																		 source[decltype(ic)::value],
+																		 source_index);
+
+					constructed_columns++;
+				};
+
+				try
+				{
+					(constructor(index_constant<I>{}), ...);
+				}
+				catch (...)
+				{
+					if (constructed_columns)
+						destruct_row(dest, dest_index, 0u, constructed_columns - 1u);
+
+					throw;
+				}
+			}
+		}
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = all_move_or_copy_constructible)
+		SOAGEN_NEVER_INLINE
+		SOAGEN_CPP20_CONSTEXPR
+		static void move_or_copy_construct_rows(column_pointers& dest,
+												size_t dest_start,
+												column_pointers& source,
+												size_t source_start,
+												size_t count) //
+			noexcept(all_nothrow_move_or_copy_constructible)
+		{
+			SOAGEN_ASSUME(&dest != &source || dest_start != source_start);
+
+			if constexpr (all_trivially_copyable)
+			{
+				memmove(dest, dest_start, source, source_start, count);
+			}
+			else if constexpr (all_nothrow_move_or_copy_constructible)
+			{
+				if (&dest == &source && dest_start > source_start)
+				{
+					for (size_t i = count; i-- > 0u;)
+						move_or_copy_construct_row(dest, dest_start + i, source, source_start + i);
+				}
+				else
+				{
+					for (size_t i = 0; i < count; i++)
+						move_or_copy_construct_row(dest, dest_start + i, source, source_start + i);
+				}
+			}
+			else
+			{
+				// machinery to provide strong-exception guarantee
+
+				size_t i = 0;
+
+				try
+				{
+					if (&dest == &source && dest_start > source_start)
+					{
+						for (; i-- > 0u;)
+							move_or_copy_construct_row(dest, dest_start + i, source, source_start + i);
+					}
+					else
+					{
+						for (; i < count; i++)
+							move_or_copy_construct_row(dest, dest_start + i, source, source_start + i);
+					}
+				}
+				catch (...)
+				{
+					if (&dest == &source && dest_start > source_start)
+					{
+						for (; i < count; i++)
+							move_or_copy_construct_row(dest, dest_start + i);
+					}
+					else
+					{
+						for (; i-- > 0u;)
+							move_or_copy_construct_row(dest, dest_start + i);
+					}
+					throw;
+				}
+			}
+		}
+
 		//--- move-assignment ------------------------------------------------------------------------------------------
 
 		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = all_move_assignable)
@@ -4922,6 +5219,55 @@ namespace soagen::detail
 			}
 		}
 
+		//--- move-or-copy-assignment (whichever is possible per-column) -----------------------------------------------
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = all_move_or_copy_assignable)
+		SOAGEN_NEVER_INLINE
+		SOAGEN_CPP20_CONSTEXPR
+		static void move_or_copy_assign_row(column_pointers& dest,
+											size_t dest_index,
+											column_pointers& source,
+											size_t source_index) //
+			noexcept(all_nothrow_move_or_copy_assignable)
+		{
+			SOAGEN_ASSUME(&dest != &source || dest_index != source_index);
+
+			// todo: how to provide a strong-exception guarantee here?
+
+			(column<I>::move_or_copy_assign(dest[I], dest_index, source[I], source_index), ...);
+		}
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = all_move_or_copy_assignable)
+		SOAGEN_NEVER_INLINE
+		SOAGEN_CPP20_CONSTEXPR
+		static void move_or_copy_assign_rows(column_pointers& dest,
+											 size_t dest_start,
+											 column_pointers& source,
+											 size_t source_start,
+											 size_t count) //
+			noexcept(all_nothrow_move_or_copy_assignable)
+		{
+			SOAGEN_ASSUME(&dest != &source || dest_start != source_start);
+
+			if constexpr (all_trivially_copyable)
+			{
+				memmove(dest, dest_start, source, source_start, count);
+			}
+			else
+			{
+				if (&dest == &source && dest_start > source_start)
+				{
+					for (size_t i = count; i-- > 0u;)
+						move_or_copy_assign_row(dest, dest_start + i, source, source_start + i);
+				}
+				else
+				{
+					for (size_t i = 0; i < count; i++)
+						move_or_copy_assign_row(dest, dest_start + i, source, source_start + i);
+				}
+			}
+		}
+
 		//--- swap rows ------------------------------------------------------------------------------------------------
 
 		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = all_swappable)
@@ -5040,20 +5386,20 @@ namespace soagen
 		using column = type_at_index<static_cast<size_t>(Index), detail::as_column<Columns>...>;
 
 		template <typename IndexConstant>
-		using column_from_ic = type_at_index<static_cast<size_t>(IndexConstant::value), detail::as_column<Columns>...>;
+		using column_from_ic =
+			type_at_index<static_cast<size_t>(remove_cvref<IndexConstant>::value), detail::as_column<Columns>...>;
 
 		static constexpr size_t column_alignments[column_count] = { detail::as_column<Columns>::alignment... };
 
 		static constexpr size_t largest_alignment = max(size_t{ 1 }, detail::as_column<Columns>::alignment...);
 
-		static constexpr bool rvalue_type_list_is_distinct =
-			POXY_IMPLEMENTATION_DETAIL(!(std::is_same_v<typename detail::as_column<Columns>::param_type,
+		static constexpr bool rvalues_are_distinct =
+			!(std::is_same_v<typename detail::as_column<Columns>::param_type,
 														typename detail::as_column<Columns>::rvalue_type>
-										 && ...));
+										 && ...);
 
 		template <typename BackingTable, typename... Args>
-		static constexpr bool emplace_back_is_nothrow =
-			noexcept(std::declval<BackingTable>().emplace_back(std::declval<Args>()...));
+		static constexpr bool emplace_back_is_nothrow = has_nothrow_emplace_back_member<BackingTable, Args...>;
 
 		template <typename BackingTable>
 		static constexpr bool push_back_is_nothrow =
@@ -5067,9 +5413,7 @@ namespace soagen
 		static constexpr bool row_push_back_is_nothrow = emplace_back_is_nothrow<BackingTable, Row>;
 
 		template <typename BackingTable, typename... Args>
-		static constexpr bool emplace_is_nothrow =
-			noexcept(std::declval<BackingTable>().emplace(typename remove_cvref<BackingTable>::size_type{},
-														  std::declval<Args>()...));
+		static constexpr bool emplace_is_nothrow = has_nothrow_emplace_member<BackingTable, std::size_t, Args...>;
 
 		template <typename BackingTable>
 		static constexpr bool insert_is_nothrow =
@@ -5098,7 +5442,7 @@ namespace soagen
 
 	template <typename T>
 	inline constexpr bool is_table_traits =
-		POXY_IMPLEMENTATION_DETAIL(detail::is_table_traits_<std::remove_cv_t<T>>::value);
+		detail::is_table_traits_<std::remove_cv_t<T>>::value;
 }
 
 namespace soagen::detail
@@ -5202,8 +5546,8 @@ namespace soagen
 		iterator& operator=(const iterator&) = default;
 
 		SOAGEN_NODISCARD_CTOR
-		constexpr iterator(soa_ref soa, difference_type pos) noexcept //
-			: base{ const_cast<soa_type*>(&soa), pos }
+		constexpr iterator(soa_ref src, difference_type pos) noexcept //
+			: base{ const_cast<soa_type*>(&src), pos }
 		{}
 
 		friend constexpr iterator& operator++(iterator& it) noexcept // pre
@@ -6419,8 +6763,8 @@ namespace soagen::detail
 		SOAGEN_NEVER_INLINE
 		void adjust_capacity(size_t new_capacity) noexcept(
 			base::allocate_is_nothrow
-			&& (Traits::all_nothrow_move_constructible
-				|| (Traits::all_nothrow_default_constructible && Traits::all_nothrow_move_assignable)
+			&& (Traits::all_nothrow_move_or_copy_constructible
+				|| (Traits::all_nothrow_default_constructible && Traits::all_nothrow_move_or_copy_assignable)
 				|| Traits::all_nothrow_copy_constructible
 				|| (Traits::all_nothrow_default_constructible && Traits::all_nothrow_copy_assignable)))
 		{
@@ -6447,14 +6791,15 @@ namespace soagen::detail
 				// when an exception is raised), so we're moving or copying the elements according to the 'most nothrow'
 				// path that still fulfills the brief.
 
-				if constexpr (Traits::all_nothrow_move_constructible)
+				if constexpr (Traits::all_nothrow_move_or_copy_constructible)
 				{
-					Traits::move_construct_rows(new_alloc.columns, {}, base::alloc_.columns, {}, base::count_);
+					Traits::move_or_copy_construct_rows(new_alloc.columns, {}, base::alloc_.columns, {}, base::count_);
 				}
-				else if constexpr (Traits::all_nothrow_default_constructible && Traits::all_nothrow_move_assignable)
+				else if constexpr (Traits::all_nothrow_default_constructible
+								   && Traits::all_nothrow_move_or_copy_assignable)
 				{
 					Traits::default_construct_rows(new_alloc.columns, {}, base::count_);
-					Traits::move_assign_rows(new_alloc.columns, {}, base::alloc_.columns, {}, base::count_);
+					Traits::move_or_copy_assign_rows(new_alloc.columns, {}, base::alloc_.columns, {}, base::count_);
 				}
 				else if constexpr (Traits::all_nothrow_copy_constructible)
 				{
@@ -6470,19 +6815,19 @@ namespace soagen::detail
 					[[maybe_unused]] bool needs_destruct = false;
 					try
 					{
-						if constexpr (Traits::all_move_constructible)
+						if constexpr (Traits::all_move_or_copy_constructible)
 						{
-							Traits::move_construct_rows(new_alloc,
-														{},
-														base::alloc_.columns,
-														{},
-														base::count_); // strong
+							Traits::move_or_copy_construct_rows(new_alloc,
+																{},
+																base::alloc_.columns,
+																{},
+																base::count_); // strong
 						}
-						else if constexpr (Traits::all_default_constructible && Traits::all_move_assignable)
+						else if constexpr (Traits::all_default_constructible && Traits::all_move_or_copy_assignable)
 						{
 							Traits::default_construct_rows(new_alloc, {}, base::count_); // strong
 							needs_destruct = !Traits::all_trivially_destructible;
-							Traits::move_assign_rows(new_alloc, {}, base::alloc_.columns, {}, base::count_);
+							Traits::move_or_copy_assign_rows(new_alloc, {}, base::alloc_.columns, {}, base::count_);
 						}
 						else if constexpr (Traits::all_copy_constructible)
 						{
@@ -6709,14 +7054,14 @@ namespace soagen::detail
 			base::count_++;
 		}
 
-		SOAGEN_CONSTRAINED_TEMPLATE(Traits::all_move_constructible	   //
-										&& Traits::all_move_assignable //
-											&& Traits::template row_constructible_from<Args&&...>,
+		SOAGEN_CONSTRAINED_TEMPLATE((Traits::all_move_or_copy_constructible //
+									 && Traits::all_move_or_copy_assignable //
+									 && Traits::template row_constructible_from<Args&&...>),
 									typename... Args)
 		SOAGEN_CPP20_CONSTEXPR
 		void emplace(size_t position, Args&&... args) noexcept(					  //
-			Traits::all_nothrow_move_constructible								  //
-				&& Traits::all_nothrow_move_assignable							  //
+			Traits::all_nothrow_move_or_copy_constructible						  //
+				&& Traits::all_nothrow_move_or_copy_assignable					  //
 					&& Traits::template row_nothrow_constructible_from<Args&&...> //
 						&& noexcept(this->grow_if_necessary(size_t{})))
 		{
@@ -6730,25 +7075,30 @@ namespace soagen::detail
 				return;
 			}
 
-			// move construct the last element (since it is new)
+			// move-construct the last element (since it is new)
 			grow_if_necessary(1u);
-			Traits::move_construct_row(base::alloc_.columns, base::count_, base::alloc_.columns, base::count_ - 1u);
+			Traits::move_or_copy_construct_row(base::alloc_.columns,
+											   base::count_,
+											   base::alloc_.columns,
+											   base::count_ - 1u);
 
 			// move-assign the rest of the elements (they were already alive)
 			if (position + 1u < base::count_)
 			{
-				Traits::move_assign_rows(base::alloc_.columns,
-										 position + 1u,
-										 base::alloc_.columns,
-										 position,
-										 base::count_ - position - 1u);
+				Traits::move_or_copy_assign_rows(base::alloc_.columns,
+												 position + 1u,
+												 base::alloc_.columns,
+												 position,
+												 base::count_ - position - 1u);
 			}
 
-			// todo: there might be some inputs that allow us to move-assign instead of destruct+construct
+			// destruct the existing element if necessary
 			if constexpr (!Traits::all_trivially_destructible)
 			{
 				Traits::destruct_row(base::alloc_.columns, position);
 			}
+
+			// insert the new element by direct construction
 			Traits::construct_row(base::alloc_.columns, position, static_cast<Args&&>(args)...);
 
 			base::count_++;
@@ -6786,8 +7136,9 @@ namespace soagen::detail
 				if constexpr (actual_alignment<table_type, static_cast<size_t>(A)>
 							  == actual_alignment<table_type, static_cast<size_t>(B)>)
 				{
-					std::swap(base::alloc_.columns[static_cast<size_t>(A)],
-							  base::alloc_.columns[static_cast<size_t>(B)]);
+					const auto temp								 = base::alloc_.columns[static_cast<size_t>(A)];
+					base::alloc_.columns[static_cast<size_t>(A)] = base::alloc_.columns[static_cast<size_t>(B)];
+					base::alloc_.columns[static_cast<size_t>(B)] = temp;
 				}
 				else
 				{
@@ -6865,7 +7216,7 @@ namespace soagen::detail
 			  typename Allocator,
 			  bool UseBase = !std::is_move_assignable_v<SOAGEN_BASE_TYPE>
 						  || allocator_traits<Allocator>::container_move_assign_always_takes_ownership,
-			  bool Movable = (Traits::all_move_assignable && Traits::all_move_constructible)>
+			  bool Movable = (Traits::all_move_or_copy_assignable && Traits::all_move_or_copy_constructible)>
 	class SOAGEN_EMPTY_BASES table_move_assign //
 		: public SOAGEN_BASE_TYPE
 	{
@@ -6887,8 +7238,8 @@ namespace soagen::detail
 		static_assert(Movable);
 
 		table_move_assign& operator=(table_move_assign&& rhs) noexcept( //
-			Traits::all_nothrow_move_assignable							//
-				&& Traits::all_nothrow_move_constructible				//
+			Traits::all_nothrow_move_or_copy_assignable					//
+				&& Traits::all_nothrow_move_or_copy_constructible		//
 					&& noexcept(base::clear())							//
 						&& noexcept(base::pop_back())					//
 							&& noexcept(base::reserve(size_t{})))
@@ -6917,12 +7268,12 @@ namespace soagen::detail
 
 			const auto assigned_end = min(base::size(), rhs.size());
 			for (size_t i = 0; i < assigned_end; i++)
-				Traits::move_assign_row(base::alloc_.columns, i, rhs.alloc_.columns, i);
+				Traits::move_or_copy_assign_row(base::alloc_.columns, i, rhs.alloc_.columns, i);
 
 			const auto constructed_end = max(base::size(), rhs.size());
 			for (size_t i = assigned_end; i < constructed_end; i++)
 			{
-				Traits::move_construct_row(base::alloc_.columns, i, rhs.alloc_.columns, i);
+				Traits::move_or_copy_construct_row(base::alloc_.columns, i, rhs.alloc_.columns, i);
 				base::count_++;
 			}
 
@@ -7105,7 +7456,7 @@ namespace soagen::detail
 
 	template <typename Traits,
 			  typename Allocator,
-			  bool = Traits::all_move_assignable>
+			  bool = Traits::all_move_or_copy_assignable>
 	class SOAGEN_EMPTY_BASES table_row_erasure //
 		: public SOAGEN_BASE_TYPE
 	{
@@ -7117,18 +7468,18 @@ namespace soagen::detail
 
 		SOAGEN_DEFAULT_RULE_OF_FIVE(table_row_erasure);
 
-		void erase(size_t pos)							 //
-			noexcept(Traits::all_nothrow_move_assignable //
+		void erase(size_t pos)									 //
+			noexcept(Traits::all_nothrow_move_or_copy_assignable //
 						 && noexcept(base::pop_back()))
 		{
 			SOAGEN_ASSUME(pos < base::count_);
 
 			if (pos + 1u < base::count_)
-				Traits::move_assign_rows(base::alloc_.columns,
-										 pos,
-										 base::alloc_.columns,
-										 pos + 1u,
-										 base::count_ - pos - 1u);
+				Traits::move_or_copy_assign_rows(base::alloc_.columns,
+												 pos,
+												 base::alloc_.columns,
+												 pos + 1u,
+												 base::count_ - pos - 1u);
 
 			base::pop_back();
 		}
@@ -7428,11 +7779,11 @@ namespace soagen
 
 		template <auto Column>
 		using column_traits =
-			POXY_IMPLEMENTATION_DETAIL(typename table_traits::template column<static_cast<size_type>(Column)>);
+			typename table_traits::template column<static_cast<size_type>(Column)>;
 
 		template <auto Column>
 		using column_type =
-			POXY_IMPLEMENTATION_DETAIL(typename column_traits<static_cast<size_type>(Column)>::value_type);
+			typename column_traits<static_cast<size_type>(Column)>::value_type;
 
 		static constexpr size_t aligned_stride = table_traits::aligned_stride;
 
diff --git a/src/soagen/hpp/table.hpp b/src/soagen/hpp/table.hpp
index 9691fd0..8506e34 100644
--- a/src/soagen/hpp/table.hpp
+++ b/src/soagen/hpp/table.hpp
@@ -480,8 +480,8 @@ namespace soagen::detail
 		SOAGEN_NEVER_INLINE
 		void adjust_capacity(size_t new_capacity) noexcept(
 			base::allocate_is_nothrow
-			&& (Traits::all_nothrow_move_constructible
-				|| (Traits::all_nothrow_default_constructible && Traits::all_nothrow_move_assignable)
+			&& (Traits::all_nothrow_move_or_copy_constructible
+				|| (Traits::all_nothrow_default_constructible && Traits::all_nothrow_move_or_copy_assignable)
 				|| Traits::all_nothrow_copy_constructible
 				|| (Traits::all_nothrow_default_constructible && Traits::all_nothrow_copy_assignable)))
 		{
@@ -508,14 +508,15 @@ namespace soagen::detail
 				// when an exception is raised), so we're moving or copying the elements according to the 'most nothrow'
 				// path that still fulfills the brief.
 
-				if constexpr (Traits::all_nothrow_move_constructible)
+				if constexpr (Traits::all_nothrow_move_or_copy_constructible)
 				{
-					Traits::move_construct_rows(new_alloc.columns, {}, base::alloc_.columns, {}, base::count_);
+					Traits::move_or_copy_construct_rows(new_alloc.columns, {}, base::alloc_.columns, {}, base::count_);
 				}
-				else if constexpr (Traits::all_nothrow_default_constructible && Traits::all_nothrow_move_assignable)
+				else if constexpr (Traits::all_nothrow_default_constructible
+								   && Traits::all_nothrow_move_or_copy_assignable)
 				{
 					Traits::default_construct_rows(new_alloc.columns, {}, base::count_);
-					Traits::move_assign_rows(new_alloc.columns, {}, base::alloc_.columns, {}, base::count_);
+					Traits::move_or_copy_assign_rows(new_alloc.columns, {}, base::alloc_.columns, {}, base::count_);
 				}
 				else if constexpr (Traits::all_nothrow_copy_constructible)
 				{
@@ -531,19 +532,19 @@ namespace soagen::detail
 					[[maybe_unused]] bool needs_destruct = false;
 					try
 					{
-						if constexpr (Traits::all_move_constructible)
+						if constexpr (Traits::all_move_or_copy_constructible)
 						{
-							Traits::move_construct_rows(new_alloc,
-														{},
-														base::alloc_.columns,
-														{},
-														base::count_); // strong
+							Traits::move_or_copy_construct_rows(new_alloc,
+																{},
+																base::alloc_.columns,
+																{},
+																base::count_); // strong
 						}
-						else if constexpr (Traits::all_default_constructible && Traits::all_move_assignable)
+						else if constexpr (Traits::all_default_constructible && Traits::all_move_or_copy_assignable)
 						{
 							Traits::default_construct_rows(new_alloc, {}, base::count_); // strong
 							needs_destruct = !Traits::all_trivially_destructible;
-							Traits::move_assign_rows(new_alloc, {}, base::alloc_.columns, {}, base::count_);
+							Traits::move_or_copy_assign_rows(new_alloc, {}, base::alloc_.columns, {}, base::count_);
 						}
 						else if constexpr (Traits::all_copy_constructible)
 						{
@@ -770,14 +771,14 @@ namespace soagen::detail
 			base::count_++;
 		}
 
-		SOAGEN_CONSTRAINED_TEMPLATE(Traits::all_move_constructible	   //
-										&& Traits::all_move_assignable //
-											&& Traits::template row_constructible_from<Args&&...>,
+		SOAGEN_CONSTRAINED_TEMPLATE((Traits::all_move_or_copy_constructible //
+									 && Traits::all_move_or_copy_assignable //
+									 && Traits::template row_constructible_from<Args&&...>),
 									typename... Args)
 		SOAGEN_CPP20_CONSTEXPR
 		void emplace(size_t position, Args&&... args) noexcept(					  //
-			Traits::all_nothrow_move_constructible								  //
-				&& Traits::all_nothrow_move_assignable							  //
+			Traits::all_nothrow_move_or_copy_constructible						  //
+				&& Traits::all_nothrow_move_or_copy_assignable					  //
 					&& Traits::template row_nothrow_constructible_from<Args&&...> //
 						&& noexcept(this->grow_if_necessary(size_t{})))
 		{
@@ -791,25 +792,30 @@ namespace soagen::detail
 				return;
 			}
 
-			// move construct the last element (since it is new)
+			// move-construct the last element (since it is new)
 			grow_if_necessary(1u);
-			Traits::move_construct_row(base::alloc_.columns, base::count_, base::alloc_.columns, base::count_ - 1u);
+			Traits::move_or_copy_construct_row(base::alloc_.columns,
+											   base::count_,
+											   base::alloc_.columns,
+											   base::count_ - 1u);
 
 			// move-assign the rest of the elements (they were already alive)
 			if (position + 1u < base::count_)
 			{
-				Traits::move_assign_rows(base::alloc_.columns,
-										 position + 1u,
-										 base::alloc_.columns,
-										 position,
-										 base::count_ - position - 1u);
+				Traits::move_or_copy_assign_rows(base::alloc_.columns,
+												 position + 1u,
+												 base::alloc_.columns,
+												 position,
+												 base::count_ - position - 1u);
 			}
 
-			// todo: there might be some inputs that allow us to move-assign instead of destruct+construct
+			// destruct the existing element if necessary
 			if constexpr (!Traits::all_trivially_destructible)
 			{
 				Traits::destruct_row(base::alloc_.columns, position);
 			}
+
+			// insert the new element by direct construction
 			Traits::construct_row(base::alloc_.columns, position, static_cast<Args&&>(args)...);
 
 			base::count_++;
@@ -847,8 +853,9 @@ namespace soagen::detail
 				if constexpr (actual_alignment<table_type, static_cast<size_t>(A)>
 							  == actual_alignment<table_type, static_cast<size_t>(B)>)
 				{
-					std::swap(base::alloc_.columns[static_cast<size_t>(A)],
-							  base::alloc_.columns[static_cast<size_t>(B)]);
+					const auto temp								 = base::alloc_.columns[static_cast<size_t>(A)];
+					base::alloc_.columns[static_cast<size_t>(A)] = base::alloc_.columns[static_cast<size_t>(B)];
+					base::alloc_.columns[static_cast<size_t>(B)] = temp;
 				}
 				else
 				{
@@ -926,7 +933,7 @@ namespace soagen::detail
 			  typename Allocator,
 			  bool UseBase = !std::is_move_assignable_v<SOAGEN_BASE_TYPE>
 						  || allocator_traits<Allocator>::container_move_assign_always_takes_ownership,
-			  bool Movable = (Traits::all_move_assignable && Traits::all_move_constructible)>
+			  bool Movable = (Traits::all_move_or_copy_assignable && Traits::all_move_or_copy_constructible)>
 	class SOAGEN_EMPTY_BASES table_move_assign //
 		: public SOAGEN_BASE_TYPE
 	{
@@ -948,8 +955,8 @@ namespace soagen::detail
 		static_assert(Movable);
 
 		table_move_assign& operator=(table_move_assign&& rhs) noexcept( //
-			Traits::all_nothrow_move_assignable							//
-				&& Traits::all_nothrow_move_constructible				//
+			Traits::all_nothrow_move_or_copy_assignable					//
+				&& Traits::all_nothrow_move_or_copy_constructible		//
 					&& noexcept(base::clear())							//
 						&& noexcept(base::pop_back())					//
 							&& noexcept(base::reserve(size_t{})))
@@ -978,12 +985,12 @@ namespace soagen::detail
 
 			const auto assigned_end = min(base::size(), rhs.size());
 			for (size_t i = 0; i < assigned_end; i++)
-				Traits::move_assign_row(base::alloc_.columns, i, rhs.alloc_.columns, i);
+				Traits::move_or_copy_assign_row(base::alloc_.columns, i, rhs.alloc_.columns, i);
 
 			const auto constructed_end = max(base::size(), rhs.size());
 			for (size_t i = assigned_end; i < constructed_end; i++)
 			{
-				Traits::move_construct_row(base::alloc_.columns, i, rhs.alloc_.columns, i);
+				Traits::move_or_copy_construct_row(base::alloc_.columns, i, rhs.alloc_.columns, i);
 				base::count_++;
 			}
 
@@ -1166,7 +1173,7 @@ namespace soagen::detail
 
 	template <typename Traits,
 			  typename Allocator,
-			  bool = Traits::all_move_assignable>
+			  bool = Traits::all_move_or_copy_assignable>
 	class SOAGEN_EMPTY_BASES table_row_erasure //
 		: public SOAGEN_BASE_TYPE
 	{
@@ -1178,18 +1185,18 @@ namespace soagen::detail
 
 		SOAGEN_DEFAULT_RULE_OF_FIVE(table_row_erasure);
 
-		void erase(size_t pos)							 //
-			noexcept(Traits::all_nothrow_move_assignable //
+		void erase(size_t pos)									 //
+			noexcept(Traits::all_nothrow_move_or_copy_assignable //
 						 && noexcept(base::pop_back()))
 		{
 			SOAGEN_ASSUME(pos < base::count_);
 
 			if (pos + 1u < base::count_)
-				Traits::move_assign_rows(base::alloc_.columns,
-										 pos,
-										 base::alloc_.columns,
-										 pos + 1u,
-										 base::count_ - pos - 1u);
+				Traits::move_or_copy_assign_rows(base::alloc_.columns,
+												 pos,
+												 base::alloc_.columns,
+												 pos + 1u,
+												 base::count_ - pos - 1u);
 
 			base::pop_back();
 		}
diff --git a/src/soagen/hpp/table_traits.hpp b/src/soagen/hpp/table_traits.hpp
index dc91f2d..2a945b3 100644
--- a/src/soagen/hpp/table_traits.hpp
+++ b/src/soagen/hpp/table_traits.hpp
@@ -36,7 +36,7 @@ namespace soagen::detail
 		using column = type_at_index<static_cast<size_t>(Index), Columns...>;
 
 		template <typename IndexConstant>
-		using column_from_ic = type_at_index<static_cast<size_t>(IndexConstant::value), Columns...>;
+		using column_from_ic = type_at_index<static_cast<size_t>(remove_cvref<IndexConstant>::value), Columns...>;
 
 		template <auto Index>
 		using storage_type = typename column<static_cast<size_t>(Index)>::storage_type;
@@ -63,14 +63,6 @@ namespace soagen::detail
 
 		static constexpr bool any_trivially_copyable = (false || ... || Columns::is_trivially_copyable);
 
-		// copy-constructibility
-
-		static constexpr bool all_copy_constructible = (Columns::is_copy_constructible && ...);
-
-		static constexpr bool all_nothrow_copy_constructible = (Columns::is_nothrow_copy_constructible && ...);
-
-		static constexpr bool all_trivially_copy_constructible = (Columns::is_trivially_copy_constructible && ...);
-
 		// move-constructibility
 
 		static constexpr bool all_move_constructible = (Columns::is_move_constructible && ...);
@@ -79,6 +71,22 @@ namespace soagen::detail
 
 		static constexpr bool all_trivially_move_constructible = (Columns::is_trivially_move_constructible && ...);
 
+		// move-assignability
+
+		static constexpr bool all_move_assignable = (Columns::is_move_assignable && ...);
+
+		static constexpr bool all_nothrow_move_assignable = (Columns::is_nothrow_move_assignable && ...);
+
+		static constexpr bool all_trivially_move_assignable = (Columns::is_trivially_move_assignable && ...);
+
+		// copy-constructibility
+
+		static constexpr bool all_copy_constructible = (Columns::is_copy_constructible && ...);
+
+		static constexpr bool all_nothrow_copy_constructible = (Columns::is_nothrow_copy_constructible && ...);
+
+		static constexpr bool all_trivially_copy_constructible = (Columns::is_trivially_copy_constructible && ...);
+
 		// copy-assignability
 
 		static constexpr bool all_copy_assignable = (Columns::is_copy_assignable && ...);
@@ -87,13 +95,25 @@ namespace soagen::detail
 
 		static constexpr bool all_trivially_copy_assignable = (Columns::is_trivially_copy_assignable && ...);
 
-		// move-assignability
+		// move-or-copy-constructibility
 
-		static constexpr bool all_move_assignable = (Columns::is_move_assignable && ...);
+		static constexpr bool all_move_or_copy_constructible = (Columns::is_move_or_copy_constructible && ...);
 
-		static constexpr bool all_nothrow_move_assignable = (Columns::is_nothrow_move_assignable && ...);
+		static constexpr bool all_nothrow_move_or_copy_constructible =
+			(Columns::is_nothrow_move_or_copy_constructible && ...);
 
-		static constexpr bool all_trivially_move_assignable = (Columns::is_trivially_move_assignable && ...);
+		static constexpr bool all_trivially_move_or_copy_constructible =
+			(Columns::is_trivially_move_or_copy_constructible && ...);
+
+		// move-or-copy-assignability
+
+		static constexpr bool all_move_or_copy_assignable = (Columns::is_move_or_copy_assignable && ...);
+
+		static constexpr bool all_nothrow_move_or_copy_assignable =
+			(Columns::is_nothrow_move_or_copy_assignable && ...);
+
+		static constexpr bool all_trivially_move_or_copy_assignable =
+			(Columns::is_trivially_move_or_copy_assignable && ...);
 
 		// destructibility
 
@@ -404,11 +424,13 @@ namespace soagen::detail
 
 					const auto constructor =
 						[&](auto ic, auto&& arg) noexcept(
-							std::is_nothrow_constructible_v<storage_type<decltype(ic)::value>, decltype(arg)&&>)
+							column_from_ic<decltype(ic)>::template is_nothrow_constructible<decltype(arg)>)
 					{
+						static_assert(std::is_reference_v<decltype(arg)>);
+
 						column_from_ic<decltype(ic)>::construct_at(columns[decltype(ic)::value],
 																   index,
-																   static_cast<decltype(arg)&&>(arg));
+																   static_cast<decltype(arg)>(arg));
 
 						constructed_columns++;
 					};
@@ -452,7 +474,7 @@ namespace soagen::detail
 				size_t constructed_columns = {};
 
 				const auto constructor =
-					[&](auto ic) noexcept(std::is_nothrow_move_constructible_v<storage_type<decltype(ic)::value>>)
+					[&](auto ic) noexcept(column_from_ic<decltype(ic)>::is_nothrow_move_constructible)
 				{
 					column_from_ic<decltype(ic)>::move_construct(dest[decltype(ic)::value],
 																 dest_index,
@@ -565,7 +587,7 @@ namespace soagen::detail
 				size_t constructed_columns = {};
 
 				const auto constructor =
-					[&](auto ic) noexcept(std::is_nothrow_copy_constructible_v<storage_type<decltype(ic)::value>>)
+					[&](auto ic) noexcept(column_from_ic<decltype(ic)>::is_nothrow_copy_constructible)
 				{
 					column_from_ic<decltype(ic)>::copy_construct(dest[decltype(ic)::value],
 																 dest_index,
@@ -654,6 +676,119 @@ namespace soagen::detail
 			}
 		}
 
+		//--- move-or-copy-construction (whichever is possible per-column) ---------------------------------------------
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = all_move_or_copy_constructible)
+		SOAGEN_NEVER_INLINE
+		SOAGEN_CPP20_CONSTEXPR
+		static void move_or_copy_construct_row(column_pointers& dest,
+											   size_t dest_index,
+											   column_pointers& source,
+											   size_t source_index) //
+			noexcept(all_nothrow_move_or_copy_constructible)
+		{
+			SOAGEN_ASSUME(&dest != &source || dest_index != source_index);
+
+			if constexpr (all_nothrow_move_or_copy_constructible || all_trivially_destructible)
+			{
+				(column<I>::move_or_copy_construct(dest[I], dest_index, source[I], source_index), ...);
+			}
+			else
+			{
+				// machinery to provide strong-exception guarantee
+
+				size_t constructed_columns = {};
+
+				const auto constructor =
+					[&](auto ic) noexcept(column_from_ic<decltype(ic)>::is_nothrow_move_or_copy_constructible)
+				{
+					column_from_ic<decltype(ic)>::move_or_copy_construct(dest[decltype(ic)::value],
+																		 dest_index,
+																		 source[decltype(ic)::value],
+																		 source_index);
+
+					constructed_columns++;
+				};
+
+				try
+				{
+					(constructor(index_constant<I>{}), ...);
+				}
+				catch (...)
+				{
+					if (constructed_columns)
+						destruct_row(dest, dest_index, 0u, constructed_columns - 1u);
+
+					throw;
+				}
+			}
+		}
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = all_move_or_copy_constructible)
+		SOAGEN_NEVER_INLINE
+		SOAGEN_CPP20_CONSTEXPR
+		static void move_or_copy_construct_rows(column_pointers& dest,
+												size_t dest_start,
+												column_pointers& source,
+												size_t source_start,
+												size_t count) //
+			noexcept(all_nothrow_move_or_copy_constructible)
+		{
+			SOAGEN_ASSUME(&dest != &source || dest_start != source_start);
+
+			if constexpr (all_trivially_copyable)
+			{
+				memmove(dest, dest_start, source, source_start, count);
+			}
+			else if constexpr (all_nothrow_move_or_copy_constructible)
+			{
+				if (&dest == &source && dest_start > source_start)
+				{
+					for (size_t i = count; i-- > 0u;)
+						move_or_copy_construct_row(dest, dest_start + i, source, source_start + i);
+				}
+				else
+				{
+					for (size_t i = 0; i < count; i++)
+						move_or_copy_construct_row(dest, dest_start + i, source, source_start + i);
+				}
+			}
+			else
+			{
+				// machinery to provide strong-exception guarantee
+
+				size_t i = 0;
+
+				try
+				{
+					if (&dest == &source && dest_start > source_start)
+					{
+						for (; i-- > 0u;)
+							move_or_copy_construct_row(dest, dest_start + i, source, source_start + i);
+					}
+					else
+					{
+						for (; i < count; i++)
+							move_or_copy_construct_row(dest, dest_start + i, source, source_start + i);
+					}
+				}
+				catch (...)
+				{
+					if (&dest == &source && dest_start > source_start)
+					{
+						for (; i < count; i++)
+							move_or_copy_construct_row(dest, dest_start + i);
+					}
+					else
+					{
+						for (; i-- > 0u;)
+							move_or_copy_construct_row(dest, dest_start + i);
+					}
+					throw;
+				}
+			}
+		}
+
 		//--- move-assignment ------------------------------------------------------------------------------------------
 
 		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = all_move_assignable)
@@ -752,6 +887,55 @@ namespace soagen::detail
 			}
 		}
 
+		//--- move-or-copy-assignment (whichever is possible per-column) -----------------------------------------------
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = all_move_or_copy_assignable)
+		SOAGEN_NEVER_INLINE
+		SOAGEN_CPP20_CONSTEXPR
+		static void move_or_copy_assign_row(column_pointers& dest,
+											size_t dest_index,
+											column_pointers& source,
+											size_t source_index) //
+			noexcept(all_nothrow_move_or_copy_assignable)
+		{
+			SOAGEN_ASSUME(&dest != &source || dest_index != source_index);
+
+			// todo: how to provide a strong-exception guarantee here?
+
+			(column<I>::move_or_copy_assign(dest[I], dest_index, source[I], source_index), ...);
+		}
+
+		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = all_move_or_copy_assignable)
+		SOAGEN_NEVER_INLINE
+		SOAGEN_CPP20_CONSTEXPR
+		static void move_or_copy_assign_rows(column_pointers& dest,
+											 size_t dest_start,
+											 column_pointers& source,
+											 size_t source_start,
+											 size_t count) //
+			noexcept(all_nothrow_move_or_copy_assignable)
+		{
+			SOAGEN_ASSUME(&dest != &source || dest_start != source_start);
+
+			if constexpr (all_trivially_copyable)
+			{
+				memmove(dest, dest_start, source, source_start, count);
+			}
+			else
+			{
+				if (&dest == &source && dest_start > source_start)
+				{
+					for (size_t i = count; i-- > 0u;)
+						move_or_copy_assign_row(dest, dest_start + i, source, source_start + i);
+				}
+				else
+				{
+					for (size_t i = 0; i < count; i++)
+						move_or_copy_assign_row(dest, dest_start + i, source, source_start + i);
+				}
+			}
+		}
+
 		//--- swap rows ------------------------------------------------------------------------------------------------
 
 		SOAGEN_HIDDEN_CONSTRAINT(sfinae, auto sfinae = all_swappable)
@@ -884,7 +1068,8 @@ namespace soagen
 
 		/// @brief	Same as #column but takes an #index_constant.
 		template <typename IndexConstant>
-		using column_from_ic = type_at_index<static_cast<size_t>(IndexConstant::value), detail::as_column<Columns>...>;
+		using column_from_ic =
+			type_at_index<static_cast<size_t>(remove_cvref<IndexConstant>::value), detail::as_column<Columns>...>;
 
 		/// @brief Array containing the `alignment` for each column.
 		static constexpr size_t column_alignments[column_count] = { detail::as_column<Columns>::alignment... };
@@ -893,8 +1078,8 @@ namespace soagen
 		static constexpr size_t largest_alignment = max(size_t{ 1 }, detail::as_column<Columns>::alignment...);
 
 		/// @brief True if the arguments passed to the rvalue overloads of `push_back()`
-		/// and `insert()` would be distinct from the regular const lvalue  overload.
-		static constexpr bool rvalue_type_list_is_distinct =
+		/// and `insert()` would be distinct from the regular const lvalue overload.
+		static constexpr bool rvalues_are_distinct =
 			POXY_IMPLEMENTATION_DETAIL(!(std::is_same_v<typename detail::as_column<Columns>::param_type,
 														typename detail::as_column<Columns>::rvalue_type>
 										 && ...));
@@ -903,8 +1088,7 @@ namespace soagen
 		/// @tparam BackingTable The backing #soagen::table type.
 		/// @tparam Args The args being passed to #soagen::table::emplace_back().
 		template <typename BackingTable, typename... Args>
-		static constexpr bool emplace_back_is_nothrow =
-			noexcept(std::declval<BackingTable>().emplace_back(std::declval<Args>()...));
+		static constexpr bool emplace_back_is_nothrow = has_nothrow_emplace_back_member<BackingTable, Args...>;
 
 		/// @brief True if a generated class's lvalue `push_back()` would be nothrow.
 		/// @tparam BackingTable The backing #soagen::table type.
@@ -928,9 +1112,7 @@ namespace soagen
 		/// @tparam BackingTable The backing #soagen::table type.
 		/// @tparam Args The args being passed to #soagen::table::emplace().
 		template <typename BackingTable, typename... Args>
-		static constexpr bool emplace_is_nothrow =
-			noexcept(std::declval<BackingTable>().emplace(typename remove_cvref<BackingTable>::size_type{},
-														  std::declval<Args>()...));
+		static constexpr bool emplace_is_nothrow = has_nothrow_emplace_member<BackingTable, std::size_t, Args...>;
 
 		/// @brief True if a generated class's lvalue `insert()` would be nothrow.
 		/// @tparam BackingTable The backing #soagen::table type.
diff --git a/src/soagen/main.py b/src/soagen/main.py
index e39b49f..0a9c20f 100644
--- a/src/soagen/main.py
+++ b/src/soagen/main.py
@@ -426,6 +426,8 @@ def main_impl():
             configs.update([f for f in Path('.').glob(config) if f.is_file()])
         else:
             config = Path(config)
+            if not config.suffix:
+                config = config.with_suffix('.toml')
             if config not in configs:
                 if not config.exists() or not config.is_file():
                     log.e(rf"configs: '{config}' did not exist or was not a file")
@@ -493,6 +495,7 @@ def on_flush(o: Writer, s: str) -> str:
                         s = re.sub(
                             r'SOAGEN_HIDDEN\s*\(\s*template\s*<(.+?)\s*>\s*\)', r'template <\1>', s, flags=re.DOTALL
                         )
+                        s = re.sub(r'POXY_IMPLEMENTATION_DETAIL\((.+?)\);', r'\1;', s, flags=re.DOTALL)
                     return s
 
                 with Writer(
diff --git a/src/soagen/preprocessor.py b/src/soagen/preprocessor.py
index f31ba67..206a274 100644
--- a/src/soagen/preprocessor.py
+++ b/src/soagen/preprocessor.py
@@ -75,6 +75,8 @@ def get_relative_path(path: Path, relative_to: Path) -> Path:
     (re.compile(r'#if[ \t]+SOAGEN_DOXYGEN\s*?(?:\n+[^#]*?)?\n+\s*?#endif'), r'\n'),
     # #if !SOAGEN_DOXYGEN ... #endif
     (re.compile(r'#if[ \t]+![ \t]*SOAGEN_DOXYGEN\s*?\n+([^#]*?)\n+\s*?#endif'), r'\1\n'),
+    # hidden implementation details
+    (re.compile(r'POXY_IMPLEMENTATION_DETAIL\((.+?)\);', flags=re.DOTALL), r'\1;'),
 )
 
 
diff --git a/src/soagen/struct.py b/src/soagen/struct.py
index 10859da..34818f6 100644
--- a/src/soagen/struct.py
+++ b/src/soagen/struct.py
@@ -5,6 +5,7 @@
 # SPDX-License-Identifier: MIT
 
 from io import StringIO
+import re
 
 from . import cpp, log, utils
 from .column import *
@@ -41,6 +42,10 @@ class Struct(Configurable):
             Optional(r'footer', default=''): Stripped(str),
             Optional(r'header', default=''): Stripped(str),
             Optional(r'includes', default=dict): {object: object},
+            Optional(r'mixins', default=[]): And(
+                ValueOrArray(str, name=r'mixins'),
+                Use(lambda x: utils.remove_duplicates([s.strip() for s in x if s.strip()])),
+            ),
             Optional(r'movable', default=True): bool,
             Optional(r'prologue', default=''): Stripped(str),
             Optional(r'reverse_iterators', default=False): bool,
@@ -93,6 +98,22 @@ def __init__(self, cfg, name, vals):
         if r'__declspec(empty_bases)' in self.attributes:
             self.attributes.remove(r'__declspec(empty_bases)')
 
+        self.mixins = utils.remove_duplicates(
+            [
+                rf'soagen::mixins::size_and_capacity',
+                rf'soagen::mixins::resizable',
+                rf'soagen::mixins::equality_comparable',
+                rf'soagen::mixins::less_than_comparable',
+                rf'soagen::mixins::data_ptr',
+                rf'soagen::mixins::columns',
+                rf'soagen::mixins::rows',
+                rf'soagen::mixins::iterators',
+                rf'soagen::mixins::spans',
+            ]
+            + ([rf'soagen::mixins::swappable'] if self.swappable else [])
+            + self.mixins
+        )
+
         with SchemaContext('includes'):
             self.includes = Includes(cfg, self.includes)
 
@@ -191,53 +212,69 @@ def write_forward_declarations(self, o: Writer):
         with MetaScope(self):
             o(rf'class {self.type};')
 
-    def write_soagen_detail_specializations(self, o: Writer):
-        with MetaScope(self):
-            for col in self.columns:
-                o(rf'SOAGEN_MAKE_NAMED_COLUMN({self.qualified_name}, {col.index}, {col.name});')
+    def write_impl_namespace(self, o: Writer):
+        namespace = rf'soagen_struct_impl::{self.config.namespace}::{self.name}'
+        namespace = namespace.replace(r':', r'_').strip(r'_')
+        namespace = re.sub(r'__+', r'_', namespace)
+        self.global_impl_namespace = namespace
+        with Namespace(o, self.global_impl_namespace):
+            if self.config.namespace:
+                o(r'SOAGEN_DISABLE_WARNINGS;')
+                o(rf'using namespace {self.config.namespace};')
+                o(r'SOAGEN_ENABLE_WARNINGS;')
+                o()
             max_length = 0
             for col in self.columns:
                 max_length = max(len(col.name), max_length)
+            left_padding = max(0, 32 - (max_length + 6)) * ' '
             with StringIO() as buf:
-                buf.write('table_traits<\n')
+                buf.write('soagen::table_traits<\n')
                 for i in range(len(self.columns)):
                     if i:
                         buf.write(f',\n')
                     col = self.columns[i]
-                    buf.write(f'{o.indent_str*5}/* {col.name:>{max_length}} */ column_traits<{col.type}')
+                    buf.write(f'{left_padding}/* {col.name:>{max_length}} */ soagen::column_traits<{col.type}')
                     if col.alignment > 0:
-                        buf.write(rf', soagen::max(size_t{{ {col.alignment} }}, alignof({col.type}))')
+                        buf.write(rf', soagen::max(std::size_t{{ {col.alignment}u }}, alignof({col.type}))')
                     if col.param_type:
                         if not col.param_type:
                             buf.write(rf', alignof({col.type})')
                         buf.write(rf', {col.param_type}')
                     buf.write(rf'>')
                 buf.write(rf'>')
-                o(
-                    rf'''
-                template <>
-                struct is_soa_<{self.qualified_name}> : std::true_type
-                {{}};
-
-                template <>
-                struct table_traits_type_<{self.qualified_name}>
-                {{
-                    using type = {buf.getvalue()};
-                }};
-
-                template <>
-                struct allocator_type_<{self.qualified_name}>
-                {{
-                    using type = {self.allocator};
-                }};
+                o(rf'using soagen_table_traits_type = {buf.getvalue()};')
+            o()
+            o(rf'using soagen_allocator_type = {self.allocator};')
 
-                template <>
-                struct table_type_<{self.qualified_name}>
-                {{
-                    using type = table<table_traits_type<{self.qualified_name}>, allocator_type<{self.qualified_name}>>;
-                }};
-                '''
-                )
+    def write_soagen_detail_specializations(self, o: Writer):
+        with MetaScope(self):
+            for col in self.columns:
+                o(rf'SOAGEN_MAKE_NAMED_COLUMN({self.qualified_name}, {col.index}, {col.name});')
+            o(
+                rf'''
+            template <>
+            struct is_soa_<{self.qualified_name}> : std::true_type
+            {{}};
+
+            template <>
+            struct table_traits_type_<{self.qualified_name}>
+            {{
+                using type = {self.global_impl_namespace}::soagen_table_traits_type;
+            }};
+
+            template <>
+            struct allocator_type_<{self.qualified_name}>
+            {{
+                using type = {self.global_impl_namespace}::soagen_allocator_type;
+            }};
+
+            template <>
+            struct table_type_<{self.qualified_name}>
+            {{
+                using type = table<table_traits_type<{self.qualified_name}>, allocator_type<{self.qualified_name}>>;
+            }};
+            '''
+            )
 
     def write_class_definition(self, o: Writer):
         with MetaScope(self):
@@ -286,18 +323,7 @@ def doxygen(s: str) -> str:
             with ClassDefinition(
                 o,
                 f'class {" ".join(self.attributes)} {self.name}',
-                hidden_base_classes=[
-                    rf'public soagen::mixins::size_and_capacity<{self.name}>',
-                    rf'public soagen::mixins::resizable<{self.name}>',
-                    rf'public soagen::mixins::equality_comparable<{self.name}>',
-                    rf'public soagen::mixins::less_than_comparable<{self.name}>',
-                    rf'public soagen::mixins::data_ptr<{self.name}>',
-                    rf'public soagen::mixins::columns<{self.name}>',
-                    rf'public soagen::mixins::rows<{self.name}>',
-                    rf'public soagen::mixins::iterators<{self.name}>',
-                    rf'public soagen::mixins::spans<{self.name}>',
-                ]
-                + ([rf'public soagen::mixins::swappable<{self.name}>'] if self.swappable else []),
+                hidden_base_classes=[rf'public {m}<{self.name}>' for m in self.mixins],
             ):
                 with Public(o):
                     o(
@@ -540,7 +566,7 @@ def doxygen(s: str) -> str:
                         @availability This method is only available when all the column types are move-assignable.""")}
                         SOAGEN_HIDDEN(template <bool sfinae = soagen::has_erase_member<table_type>>)
                         SOAGEN_ALWAYS_INLINE
-                        SOAGEN_CPP20_CONSTEXPR
+                        SOAGEN_CPP20_CONSTEXPR //
                         SOAGEN_ENABLE_IF_T({self.name}&, sfinae) erase(size_type pos) //
                             noexcept(soagen::has_nothrow_erase_member<table_type>)
                         {{
@@ -563,7 +589,7 @@ def doxygen(s: str) -> str:
                         @availability This method is only available when all the column types are move-assignable.""")}
                         SOAGEN_HIDDEN(template <bool sfinae = soagen::has_unordered_erase_member<table_type>>)
                         SOAGEN_ALWAYS_INLINE
-                        SOAGEN_CPP20_CONSTEXPR
+                        SOAGEN_CPP20_CONSTEXPR //
                         SOAGEN_ENABLE_IF_T(soagen::optional<size_type>, sfinae) unordered_erase(size_type pos) //
                             noexcept(soagen::has_nothrow_unordered_erase_member<table_type>)
                         {{
@@ -760,16 +786,17 @@ def doxygen(s: str) -> str:
                                                 sfinae.append(r'table_traits::row_constructible_from<Tuple&&>')
                                                 sfinae_template_dependent = True
                                             if rvalue_overload:
-                                                sfinae.append(r'table_traits::rvalue_type_list_is_distinct')
+                                                sfinae.append(r'table_traits::rvalues_are_distinct')
                                             if func in (r'insert', r'emplace'):
-                                                sfinae.append(r'table_traits::all_move_constructible')
-                                                sfinae.append(r'table_traits::all_move_assignable')
-                                            if func in (r'emplace_back', r'emplace'):
+                                                sfinae.append(r'table_traits::all_move_or_copy_constructible')
+                                                sfinae.append(r'table_traits::all_move_or_copy_assignable')
+                                            if func in (r'emplace_back', r'emplace') and not tuple_overload:
                                                 sfinae.append(
                                                     rf'table_traits::row_constructible_from<{",".join(types[-len(self.columns):])}>'
                                                 )
                                                 sfinae_template_dependent = True
                                             hidden_template = bool(sfinae) and not template_params
+                                            sfinae = utils.remove_duplicates(sfinae)
                                             if sfinae:
                                                 if len(sfinae) > 2:
                                                     sfinae_condition_string = f'\n{o.indent_str*7}&& '.join(sfinae)
@@ -910,21 +937,23 @@ def doxygen(s: str) -> str:
                                             s += '\tnoexcept('
                                             if func == 'push_back':
                                                 if tuple_overload:
-                                                    s += rf'table_traits::row_push_back_is_nothrow<table_type&, {types[0]}>'
+                                                    s += rf'table_traits::row_push_back_is_nothrow<table_type, {types[0]}>'
                                                 else:
-                                                    s += rf'table_traits::{"rvalue_" if rvalue_overload else ""}push_back_is_nothrow<table_type&>'
+                                                    s += rf'table_traits::{"rvalue_" if rvalue_overload else ""}push_back_is_nothrow<table_type>'
                                             elif func == 'insert':
                                                 if tuple_overload:
-                                                    s += rf'table_traits::row_insert_is_nothrow<table_type&, {types[-1]}>'
+                                                    s += (
+                                                        rf'table_traits::row_insert_is_nothrow<table_type, {types[-1]}>'
+                                                    )
                                                 else:
-                                                    s += rf'table_traits::{"rvalue_" if rvalue_overload else ""}insert_is_nothrow<table_type&>'
+                                                    s += rf'table_traits::{"rvalue_" if rvalue_overload else ""}insert_is_nothrow<table_type>'
                                             elif func == 'emplace_back':
-                                                s += rf'table_traits::emplace_back_is_nothrow<table_type&, {", ".join(types)}>'
+                                                s += rf'table_traits::emplace_back_is_nothrow<table_type, {", ".join(types)}>'
                                             elif func == 'emplace':
-                                                s += rf'table_traits::emplace_is_nothrow<table_type&, {", ".join(types[1:])}>'
+                                                s += rf'table_traits::emplace_is_nothrow<table_type, {", ".join(types[1:])}>'
                                             else:
                                                 assert False  # we should have all our bases covered by the table_traits
-                                            s += ')\n'
+                                            s += ') //\n'
 
                                             # requires(...)
                                             if sfinae:
diff --git a/tests/employees.hpp b/tests/employees.hpp
index e1aaa82..0f27a38 100644
--- a/tests/employees.hpp
+++ b/tests/employees.hpp
@@ -63,7 +63,26 @@ namespace soagen::detail
 		#define SOAGEN_NAME_tag
 		SOAGEN_MAKE_NAME(tag);
 	#endif
+}
+
+namespace soagen_struct_impl_tests_employees
+{
+	SOAGEN_DISABLE_WARNINGS;
+	using namespace tests;
+	SOAGEN_ENABLE_WARNINGS;
+
+	using soagen_table_traits_type = soagen::table_traits<
+				 /* 		 name */ soagen::column_traits<const std::string>,
+				 /* 		   id */ soagen::column_traits<unsigned long long, soagen::max(std::size_t{ 32u }, alignof(unsigned long long))>,
+				 /* date_of_birth */ soagen::column_traits<std::tuple<int, int, int>>,
+				 /* 	   salary */ soagen::column_traits<int>,
+				 /* 		  tag */ soagen::column_traits<int*>>;
+
+	using soagen_allocator_type = soagen::allocator;
+}
 
+namespace soagen::detail
+{
 	SOAGEN_MAKE_NAMED_COLUMN(tests::employees, 0, name);
 	SOAGEN_MAKE_NAMED_COLUMN(tests::employees, 1, id);
 	SOAGEN_MAKE_NAMED_COLUMN(tests::employees, 2, date_of_birth);
@@ -77,18 +96,13 @@ namespace soagen::detail
 	template <>
 	struct table_traits_type_<tests::employees>
 	{
-		using type = table_traits<
-		/*			name */ column_traits<const std::string>,
-		/*			  id */ column_traits<unsigned long long, soagen::max(size_t{ 32 }, alignof(unsigned long long))>,
-		/* date_of_birth */ column_traits<std::tuple<int, int, int>>,
-		/*		  salary */ column_traits<int>,
-		/*			 tag */ column_traits<int*>>;
+		using type = soagen_struct_impl_tests_employees::soagen_table_traits_type;
 	};
 
 	template <>
 	struct allocator_type_<tests::employees>
 	{
-		using type = soagen::allocator;
+		using type = soagen_struct_impl_tests_employees::soagen_allocator_type;
 	};
 
 	template <>
@@ -244,7 +258,7 @@ namespace tests
 
 		template <bool sfinae = soagen::has_erase_member<table_type>>
 		SOAGEN_ALWAYS_INLINE
-		SOAGEN_CPP20_CONSTEXPR
+		SOAGEN_CPP20_CONSTEXPR									  //
 		std::enable_if_t<sfinae, employees&> erase(size_type pos) //
 			noexcept(soagen::has_nothrow_erase_member<table_type>)
 		{
@@ -254,7 +268,7 @@ namespace tests
 
 		template <bool sfinae = soagen::has_unordered_erase_member<table_type>>
 		SOAGEN_ALWAYS_INLINE
-		SOAGEN_CPP20_CONSTEXPR
+		SOAGEN_CPP20_CONSTEXPR																 //
 		std::enable_if_t<sfinae, soagen::optional<size_type>> unordered_erase(size_type pos) //
 			noexcept(soagen::has_nothrow_unordered_erase_member<table_type>)
 		{
@@ -320,7 +334,7 @@ namespace tests
 							 column_traits<2>::param_type date_of_birth,
 							 column_traits<3>::param_type salary,
 							 column_traits<4>::param_type tag = nullptr) //
-			noexcept(table_traits::push_back_is_nothrow<table_type&>)
+			noexcept(table_traits::push_back_is_nothrow<table_type>)	 //
 		{
 			table_.emplace_back(static_cast<column_traits<0>::param_forward_type>(name),
 								static_cast<column_traits<1>::param_forward_type>(id),
@@ -330,15 +344,15 @@ namespace tests
 			return *this;
 		}
 
-		template <bool sfinae = table_traits::rvalue_type_list_is_distinct>
+		template <bool sfinae = table_traits::rvalues_are_distinct>
 		SOAGEN_CPP20_CONSTEXPR
 		employees& push_back(std::enable_if_t<sfinae, column_traits<0>::rvalue_type> name,
 							 column_traits<1>::rvalue_type id,
 							 column_traits<2>::rvalue_type date_of_birth,
 							 column_traits<3>::rvalue_type salary,
-							 column_traits<4>::rvalue_type tag = nullptr) //
-			noexcept(table_traits::rvalue_push_back_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct) //
+							 column_traits<4>::rvalue_type tag = nullptr)	//
+			noexcept(table_traits::rvalue_push_back_is_nothrow<table_type>) //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct)				//
 		{
 			table_.emplace_back(static_cast<column_traits<0>::rvalue_forward_type>(name),
 								static_cast<column_traits<1>::rvalue_forward_type>(id),
@@ -360,9 +374,9 @@ namespace tests
 								Id&& id,
 								DateOfBirth&& date_of_birth,
 								Salary&& salary,
-								Tag&& tag = nullptr) //
-			noexcept(table_traits::emplace_back_is_nothrow<table_type&, Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>)
-				SOAGEN_REQUIRES(table_traits::row_constructible_from<Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>) //
+								Tag&& tag = nullptr)																  //
+			noexcept(table_traits::emplace_back_is_nothrow<table_type, Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>) //
+			SOAGEN_REQUIRES(table_traits::row_constructible_from<Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>)		  //
 		{
 			table_.emplace_back(static_cast<Name&&>(name),
 								static_cast<Id&&>(id),
@@ -372,29 +386,27 @@ namespace tests
 			return *this;
 		}
 
-		template <typename Tuple,
-				  std::enable_if_t<(table_traits::row_constructible_from<Tuple&&>
-									&& table_traits::row_constructible_from<Tuple&&>),
-								   int> = 0>
+		template <typename Tuple, std::enable_if_t<table_traits::row_constructible_from<Tuple&&>, int> = 0>
 		SOAGEN_CPP20_CONSTEXPR
-		employees& emplace_back(Tuple&& tuple_) //
-			noexcept(table_traits::emplace_back_is_nothrow<table_type&, Tuple&&>) SOAGEN_REQUIRES(
-				table_traits::row_constructible_from<Tuple&&>&& table_traits::row_constructible_from<Tuple&&>) //
+		employees& emplace_back(Tuple&& tuple_)									 //
+			noexcept(table_traits::emplace_back_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(table_traits::row_constructible_from<Tuple&&>)		 //
 		{
 			table_.emplace_back(static_cast<Tuple&&>(tuple_));
 			return *this;
 		}
 
-		template <bool sfinae = (table_traits::all_move_constructible && table_traits::all_move_assignable)>
+		template <bool sfinae =
+					  (table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable)>
 		SOAGEN_CPP20_CONSTEXPR
 		std::enable_if_t<sfinae, employees&> insert(size_type index_,
 													column_traits<0>::param_type name,
 													column_traits<1>::param_type id,
 													column_traits<2>::param_type date_of_birth,
 													column_traits<3>::param_type salary,
-													column_traits<4>::param_type tag = nullptr) //
-			noexcept(table_traits::insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable) //
+													column_traits<4>::param_type tag = nullptr)						  //
+			noexcept(table_traits::insert_is_nothrow<table_type>)													  //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(index_,
 						   static_cast<column_traits<0>::param_forward_type>(name),
@@ -405,16 +417,17 @@ namespace tests
 			return *this;
 		}
 
-		template <bool sfinae = (table_traits::all_move_constructible && table_traits::all_move_assignable)>
+		template <bool sfinae =
+					  (table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable)>
 		SOAGEN_CPP20_CONSTEXPR
 		std::enable_if_t<sfinae, iterator> insert(iterator iter_,
 												  column_traits<0>::param_type name,
 												  column_traits<1>::param_type id,
 												  column_traits<2>::param_type date_of_birth,
 												  column_traits<3>::param_type salary,
-												  column_traits<4>::param_type tag = nullptr) //
-			noexcept(table_traits::insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable) //
+												  column_traits<4>::param_type tag = nullptr)						  //
+			noexcept(table_traits::insert_is_nothrow<table_type>)													  //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::param_forward_type>(name),
@@ -425,16 +438,17 @@ namespace tests
 			return iter_;
 		}
 
-		template <bool sfinae = (table_traits::all_move_constructible && table_traits::all_move_assignable)>
+		template <bool sfinae =
+					  (table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable)>
 		SOAGEN_CPP20_CONSTEXPR
 		std::enable_if_t<sfinae, const_iterator> insert(const_iterator iter_,
 														column_traits<0>::param_type name,
 														column_traits<1>::param_type id,
 														column_traits<2>::param_type date_of_birth,
 														column_traits<3>::param_type salary,
-														column_traits<4>::param_type tag = nullptr) //
-			noexcept(table_traits::insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::all_move_constructible&& table_traits::all_move_assignable) //
+														column_traits<4>::param_type tag = nullptr)					  //
+			noexcept(table_traits::insert_is_nothrow<table_type>)													  //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::param_forward_type>(name),
@@ -445,18 +459,18 @@ namespace tests
 			return iter_;
 		}
 
-		template <bool sfinae = (table_traits::rvalue_type_list_is_distinct && table_traits::all_move_constructible
-								 && table_traits::all_move_assignable)>
+		template <bool sfinae = (table_traits::rvalues_are_distinct && table_traits::all_move_or_copy_constructible
+								 && table_traits::all_move_or_copy_assignable)>
 		SOAGEN_CPP20_CONSTEXPR
 		employees& insert(std::enable_if_t<sfinae, size_type> index_,
 						  column_traits<0>::rvalue_type name,
 						  column_traits<1>::rvalue_type id,
 						  column_traits<2>::rvalue_type date_of_birth,
 						  column_traits<3>::rvalue_type salary,
-						  column_traits<4>::rvalue_type tag = nullptr) //
-			noexcept(table_traits::rvalue_insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable) //
+						  column_traits<4>::rvalue_type tag = nullptr)	 //
+			noexcept(table_traits::rvalue_insert_is_nothrow<table_type>) //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct&& table_traits::all_move_or_copy_constructible&&
+								table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(index_,
 						   static_cast<column_traits<0>::rvalue_forward_type>(name),
@@ -467,18 +481,18 @@ namespace tests
 			return *this;
 		}
 
-		template <bool sfinae = (table_traits::rvalue_type_list_is_distinct && table_traits::all_move_constructible
-								 && table_traits::all_move_assignable)>
+		template <bool sfinae = (table_traits::rvalues_are_distinct && table_traits::all_move_or_copy_constructible
+								 && table_traits::all_move_or_copy_assignable)>
 		SOAGEN_CPP20_CONSTEXPR
 		iterator insert(std::enable_if_t<sfinae, iterator> iter_,
 						column_traits<0>::rvalue_type name,
 						column_traits<1>::rvalue_type id,
 						column_traits<2>::rvalue_type date_of_birth,
 						column_traits<3>::rvalue_type salary,
-						column_traits<4>::rvalue_type tag = nullptr) //
-			noexcept(table_traits::rvalue_insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable) //
+						column_traits<4>::rvalue_type tag = nullptr)	 //
+			noexcept(table_traits::rvalue_insert_is_nothrow<table_type>) //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct&& table_traits::all_move_or_copy_constructible&&
+								table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::rvalue_forward_type>(name),
@@ -489,8 +503,8 @@ namespace tests
 			return iter_;
 		}
 
-		template <bool sfinae = (table_traits::rvalue_type_list_is_distinct && table_traits::all_move_constructible
-								 && table_traits::all_move_assignable)>
+		template <bool sfinae = (table_traits::rvalues_are_distinct && table_traits::all_move_or_copy_constructible
+								 && table_traits::all_move_or_copy_assignable)>
 		SOAGEN_CPP20_CONSTEXPR
 		const_iterator insert(std::enable_if_t<sfinae, const_iterator> iter_,
 							  column_traits<0>::rvalue_type name,
@@ -498,9 +512,9 @@ namespace tests
 							  column_traits<2>::rvalue_type date_of_birth,
 							  column_traits<3>::rvalue_type salary,
 							  column_traits<4>::rvalue_type tag = nullptr) //
-			noexcept(table_traits::rvalue_insert_is_nothrow<table_type&>)
-				SOAGEN_REQUIRES(table_traits::rvalue_type_list_is_distinct&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable) //
+			noexcept(table_traits::rvalue_insert_is_nothrow<table_type>)   //
+			SOAGEN_REQUIRES(table_traits::rvalues_are_distinct&& table_traits::all_move_or_copy_constructible&&
+								table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<column_traits<0>::rvalue_forward_type>(name),
@@ -517,7 +531,7 @@ namespace tests
 			typename DateOfBirth,
 			typename Salary,
 			typename Tag		  = column_traits<4>::default_emplace_type,
-			std::enable_if_t<(table_traits::all_move_constructible && table_traits::all_move_assignable
+			std::enable_if_t<(table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable
 							  && table_traits::row_constructible_from<Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>),
 							 int> = 0>
 		SOAGEN_CPP20_CONSTEXPR
@@ -526,11 +540,10 @@ namespace tests
 						   Id&& id,
 						   DateOfBirth&& date_of_birth,
 						   Salary&& salary,
-						   Tag&& tag = nullptr) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>)
-				SOAGEN_REQUIRES(
-					table_traits::all_move_constructible&& table_traits::all_move_assignable&&
-						table_traits::row_constructible_from<Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>) //
+						   Tag&& tag = nullptr)																	 //
+			noexcept(table_traits::emplace_is_nothrow<table_type, Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>) //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable&&
+								table_traits::row_constructible_from<Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>) //
 		{
 			table_.emplace(index_,
 						   static_cast<Name&&>(name),
@@ -547,7 +560,7 @@ namespace tests
 			typename DateOfBirth,
 			typename Salary,
 			typename Tag		  = column_traits<4>::default_emplace_type,
-			std::enable_if_t<(table_traits::all_move_constructible && table_traits::all_move_assignable
+			std::enable_if_t<(table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable
 							  && table_traits::row_constructible_from<Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>),
 							 int> = 0>
 		SOAGEN_CPP20_CONSTEXPR
@@ -556,11 +569,10 @@ namespace tests
 						 Id&& id,
 						 DateOfBirth&& date_of_birth,
 						 Salary&& salary,
-						 Tag&& tag = nullptr) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>)
-				SOAGEN_REQUIRES(
-					table_traits::all_move_constructible&& table_traits::all_move_assignable&&
-						table_traits::row_constructible_from<Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>) //
+						 Tag&& tag = nullptr)																	 //
+			noexcept(table_traits::emplace_is_nothrow<table_type, Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>) //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable&&
+								table_traits::row_constructible_from<Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<Name&&>(name),
@@ -577,7 +589,7 @@ namespace tests
 			typename DateOfBirth,
 			typename Salary,
 			typename Tag		  = column_traits<4>::default_emplace_type,
-			std::enable_if_t<(table_traits::all_move_constructible && table_traits::all_move_assignable
+			std::enable_if_t<(table_traits::all_move_or_copy_constructible && table_traits::all_move_or_copy_assignable
 							  && table_traits::row_constructible_from<Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>),
 							 int> = 0>
 		SOAGEN_CPP20_CONSTEXPR
@@ -586,11 +598,10 @@ namespace tests
 							   Id&& id,
 							   DateOfBirth&& date_of_birth,
 							   Salary&& salary,
-							   Tag&& tag = nullptr) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>)
-				SOAGEN_REQUIRES(
-					table_traits::all_move_constructible&& table_traits::all_move_assignable&&
-						table_traits::row_constructible_from<Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>) //
+							   Tag&& tag = nullptr)																 //
+			noexcept(table_traits::emplace_is_nothrow<table_type, Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>) //
+			SOAGEN_REQUIRES(table_traits::all_move_or_copy_constructible&& table_traits::all_move_or_copy_assignable&&
+								table_traits::row_constructible_from<Name&&, Id&&, DateOfBirth&&, Salary&&, Tag&&>) //
 		{
 			table_.emplace(static_cast<size_type>(iter_),
 						   static_cast<Name&&>(name),
@@ -603,14 +614,15 @@ namespace tests
 
 		template <typename Tuple,
 				  std::enable_if_t<(table_traits::row_constructible_from<Tuple&&>
-									&& table_traits::all_move_constructible && table_traits::all_move_assignable
-									&& table_traits::row_constructible_from<size_type, Tuple&&>),
+									&& table_traits::all_move_or_copy_constructible
+									&& table_traits::all_move_or_copy_assignable),
 								   int> = 0>
 		SOAGEN_CPP20_CONSTEXPR
-		employees& emplace(size_type index_, Tuple&& tuple_) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Tuple&&>) SOAGEN_REQUIRES(
-				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_constructible&&
-					table_traits::all_move_assignable&& table_traits::row_constructible_from<size_type, Tuple&&>) //
+		employees& emplace(size_type index_, Tuple&& tuple_)				//
+			noexcept(table_traits::emplace_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_or_copy_constructible&&
+					table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(index_, static_cast<Tuple&&>(tuple_));
 			return *this;
@@ -618,14 +630,15 @@ namespace tests
 
 		template <typename Tuple,
 				  std::enable_if_t<(table_traits::row_constructible_from<Tuple&&>
-									&& table_traits::all_move_constructible && table_traits::all_move_assignable
-									&& table_traits::row_constructible_from<iterator, Tuple&&>),
+									&& table_traits::all_move_or_copy_constructible
+									&& table_traits::all_move_or_copy_assignable),
 								   int> = 0>
 		SOAGEN_CPP20_CONSTEXPR
-		iterator emplace(iterator iter_, Tuple&& tuple_) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Tuple&&>) SOAGEN_REQUIRES(
-				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_constructible&&
-					table_traits::all_move_assignable&& table_traits::row_constructible_from<iterator, Tuple&&>) //
+		iterator emplace(iterator iter_, Tuple&& tuple_)					//
+			noexcept(table_traits::emplace_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_or_copy_constructible&&
+					table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_), static_cast<Tuple&&>(tuple_));
 			return iter_;
@@ -633,15 +646,15 @@ namespace tests
 
 		template <typename Tuple,
 				  std::enable_if_t<(table_traits::row_constructible_from<Tuple&&>
-									&& table_traits::all_move_constructible && table_traits::all_move_assignable
-									&& table_traits::row_constructible_from<const_iterator, Tuple&&>),
+									&& table_traits::all_move_or_copy_constructible
+									&& table_traits::all_move_or_copy_assignable),
 								   int> = 0>
 		SOAGEN_CPP20_CONSTEXPR
-		const_iterator emplace(const_iterator iter_, Tuple&& tuple_) //
-			noexcept(table_traits::emplace_is_nothrow<table_type&, Tuple&&>)
-				SOAGEN_REQUIRES(table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_constructible&&
-									table_traits::all_move_assignable&&
-										table_traits::row_constructible_from<const_iterator, Tuple&&>) //
+		const_iterator emplace(const_iterator iter_, Tuple&& tuple_)		//
+			noexcept(table_traits::emplace_is_nothrow<table_type, Tuple&&>) //
+			SOAGEN_REQUIRES(
+				table_traits::row_constructible_from<Tuple&&>&& table_traits::all_move_or_copy_constructible&&
+					table_traits::all_move_or_copy_assignable) //
 		{
 			table_.emplace(static_cast<size_type>(iter_), static_cast<Tuple&&>(tuple_));
 			return iter_;