diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 46b031ec8b775..10b48164c3fd6 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -39,12 +39,16 @@
 
 #define DECLARE_SOA_ITERATOR_METADATA()                                       \
   template <typename IT>                                                      \
-  requires(o2::soa::is_soa_iterator_v<IT>) struct MetadataTrait<IT> {         \
+  requires(o2::soa::is_iterator<IT>) struct MetadataTrait<IT> {               \
     using metadata = typename MetadataTrait<typename IT::parent_t>::metadata; \
   };
 
 namespace o2::framework
 {
+using ListVector = std::vector<std::vector<int64_t>>;
+
+std::string cutString(std::string&& str);
+
 struct OriginEnc {
   static constexpr size_t size = 4;
   uint32_t value;
@@ -107,6 +111,56 @@ DECLARE_SOA_METADATA();
 
 namespace o2::soa
 {
+/// special case for the template with origin
+template <typename T, template <o2::framework::OriginEnc, typename...> class Ref>
+struct is_specialization_origin : std::false_type {
+};
+
+template <template <o2::framework::OriginEnc, typename...> class Ref, o2::framework::OriginEnc ORIGIN, typename... Args>
+struct is_specialization_origin<Ref<ORIGIN, Args...>, Ref> : std::true_type {
+};
+
+template <typename T, template <o2::framework::OriginEnc, typename...> class Ref>
+inline constexpr bool is_specialization_origin_v = is_specialization_origin<T, Ref>::value;
+
+template <template <o2::framework::OriginEnc, typename...> class base, typename derived>
+struct is_base_of_template_origin_impl {
+  template <o2::framework::OriginEnc ORIGIN, typename... Ts>
+  static constexpr std::true_type test(const base<ORIGIN, Ts...>*);
+  static constexpr std::false_type test(...);
+  using type = decltype(test(std::declval<derived*>()));
+};
+
+template <template <o2::framework::OriginEnc, typename...> class base, typename derived>
+using is_base_of_template_origin = typename is_base_of_template_origin_impl<base, derived>::type;
+
+template <template <o2::framework::OriginEnc, typename...> class base, typename derived>
+inline constexpr bool is_base_of_template_origin_v = is_base_of_template_origin<base, derived>::value;
+
+template <typename T>
+concept not_void = requires { !std::same_as<T, void>; };
+
+// column identification concepts
+template <typename C>
+concept is_persistent_column = requires(C c) { c.mColumnIterator; };
+
+template <typename C>
+using is_persistent_t = std::conditional_t<is_persistent_column<C>, std::true_type, std::false_type>;
+
+template <typename C>
+static constexpr bool is_persistent_v = is_persistent_column<C>;
+
+template <typename C>
+concept is_index_column = requires { not_void<typename C::binding_t>; };
+
+template <typename C>
+using is_external_index_t = typename std::conditional_t<is_index_column<C>, std::true_type, std::false_type>;
+
+template <typename C>
+concept is_self_index_column = requires { typename C::self_index_t{}; };
+
+template <typename C>
+using is_self_index_t = typename std::conditional_t<is_self_index_column<C>, std::true_type, std::false_type>;
 
 struct Binding {
   void const* ptr = nullptr;
@@ -141,11 +195,8 @@ auto createFieldsFromColumns(framework::pack<C...>)
 
 using SelectionVector = std::vector<int64_t>;
 
-template <typename, typename = void>
-inline constexpr bool is_index_column_v = false;
-
 template <typename T>
-inline constexpr bool is_index_column_v<T, std::void_t<decltype(sizeof(typename T::binding_t))>> = true;
+inline constexpr bool is_index_column_v = is_index_column<T>;
 
 template <typename, typename = void>
 inline constexpr bool is_type_with_originals_v = false;
@@ -159,17 +210,11 @@ inline constexpr bool is_type_with_parent_v = false;
 template <typename T>
 inline constexpr bool is_type_with_parent_v<T, std::void_t<decltype(sizeof(typename T::parent_t))>> = true;
 
-template <typename, typename = void>
-inline constexpr bool is_type_with_metadata_v = false;
-
 template <typename T>
-inline constexpr bool is_type_with_metadata_v<T, std::void_t<decltype(sizeof(typename T::metadata))>> = true;
-
-template <typename, typename = void>
-inline constexpr bool is_type_with_binding_v = false;
+concept has_metadata = soa::not_void<typename aod::MetadataTrait<T>::metadata>;
 
 template <typename T>
-inline constexpr bool is_type_with_binding_v<T, std::void_t<decltype(sizeof(typename T::binding_t))>> = true;
+inline constexpr bool is_type_with_metadata_v = has_metadata<T>;
 
 template <typename, typename = void>
 inline constexpr bool is_type_spawnable_v = false;
@@ -195,6 +240,9 @@ inline constexpr bool is_self_index_column_v = false;
 template <typename T>
 inline constexpr bool is_self_index_column_v<T, std::void_t<decltype(sizeof(typename T::self_index_t))>> = true;
 
+template <typename T>
+concept is_spawnable_column = std::is_same_v<typename T::spawnable_t, std::true_type>;
+
 template <typename, typename = void>
 inline constexpr bool is_with_base_table_v = false;
 
@@ -608,45 +656,19 @@ struct Index : o2::soa::IndexColumn<Index<START, END>> {
 };
 
 template <typename T>
-using is_dynamic_t = framework::is_specialization<typename T::base, DynamicColumn>;
-
-namespace persistent_type_helper
-{
-// This checks both for the existence of the ::persistent member in the class T as well as the value returned stored in it.
-// Hack: a pointer to any field of type int inside persistent. Both true_type and false_type do not have any int field, but anyways we pass nullptr.
-// The compiler picks the version with exact number of arguments when only it can, i.e., when T::persistent is defined.
-template <class T>
-typename T::persistent test(int T::persistent::*);
-
-template <class>
-std::false_type test(...);
-} // namespace persistent_type_helper
-
-template <typename T>
-using is_persistent_t = decltype(persistent_type_helper::test<T>(nullptr));
+concept is_dynamic_column = framework::is_base_of_template_v<soa::DynamicColumn, T>;
 
 template <typename T>
-constexpr auto is_persistent_v = is_persistent_t<T>::value;
+using is_dynamic_t = std::conditional_t<is_dynamic_column<T>, std::true_type, std::false_type>;
 
 template <typename T>
-constexpr auto is_dynamic_v = is_dynamic_t<T>::value;
+concept is_indexing_column = framework::is_base_of_template_v<soa::IndexColumn, T>;
 
 template <typename T>
-using is_external_index_t = typename std::conditional<is_index_column_v<T>, std::true_type, std::false_type>::type;
+concept is_column = framework::is_base_of_template_v<soa::Column, T> || is_dynamic_column<T> || is_indexing_column<T> || framework::is_base_of_template_v<soa::MarkerColumn, T>;
 
 template <typename T>
-using is_self_index_t = typename std::conditional<is_self_index_column_v<T>, std::true_type, std::false_type>::type;
-
-template <typename T, template <auto...> class Ref>
-struct is_index : std::false_type {
-};
-
-template <template <auto...> class Ref, auto... Args>
-struct is_index<Ref<Args...>, Ref> : std::true_type {
-};
-
-template <typename T>
-using is_index_t = is_index<T, Index>;
+using is_indexing_t = std::conditional_t<is_indexing_column<T>, std::true_type, std::false_type>;
 
 struct IndexPolicyBase {
   /// Position inside the current table
@@ -842,6 +864,9 @@ struct DefaultIndexPolicy : IndexPolicyBase {
 template <o2::framework::OriginEnc ORIGIN, typename... C>
 class Table;
 
+template <typename T>
+concept is_table = soa::is_specialization_origin_v<T, soa::Table> || soa::is_base_of_template_origin_v<soa::Table, T>;
+
 /// Similar to a pair but not a pair, to avoid
 /// exposing the second type everywhere.
 template <typename C>
@@ -851,7 +876,7 @@ struct ColumnDataHolder {
 };
 
 template <typename T, typename B>
-concept CanBind = requires(T&& t) {
+concept can_bind = requires(T&& t) {
   { t.B::mColumnIterator };
 };
 
@@ -862,7 +887,7 @@ struct RowViewCore : public IP, C... {
   using table_t = o2::soa::Table<ORIGIN, C...>;
   using all_columns = framework::pack<C...>;
   using persistent_columns_t = framework::selected_pack<is_persistent_t, C...>;
-  using index_columns_t = framework::selected_pack<is_index_t, C...>;
+  using index_columns_t = framework::selected_pack<is_indexing_t, C...>;
   constexpr inline static bool has_index_v = framework::pack_size(index_columns_t{}) > 0;
   using external_index_columns_t = framework::selected_pack<is_external_index_t, C...>;
   using internal_index_columns_t = framework::selected_pack<is_self_index_t, C...>;
@@ -1024,10 +1049,10 @@ struct RowViewCore : public IP, C... {
   {
     using namespace o2::soa;
     auto f = framework::overloaded  {
-      [this]<typename T>(T*) -> void requires is_persistent_v<T> { T::mColumnIterator.mCurrentPos = &this->mRowIndex; },
-      [this]<typename T>(T*) -> void requires is_dynamic_v<T> { bindDynamicColumn<T>(typename T::bindings_t{});},
+      [this]<typename T>(T*) -> void requires is_persistent_column<T> { T::mColumnIterator.mCurrentPos = &this->mRowIndex; },
+      [this]<typename T>(T*) -> void requires is_dynamic_column<T> { bindDynamicColumn<T>(typename T::bindings_t{});},
       [this]<typename T>(T*) -> void {},
-};
+    };
     (f(static_cast<C*>(nullptr)), ...);
     if constexpr (has_index_v) {
       this->setIndices(this->getIndices());
@@ -1047,7 +1072,7 @@ struct RowViewCore : public IP, C... {
   // error if constructor for the table or any other thing involving a missing
   // binding is preinstanciated.
   template <typename B>
-    requires(CanBind<typename table_t::iterator, B>)
+    requires(can_bind<typename table_t::iterator, B>)
   decltype(auto) getDynamicBinding()
   {
     static_assert(std::is_same_v<decltype(&(static_cast<B*>(this)->mColumnIterator)), std::decay_t<decltype(B::mColumnIterator)>*>, "foo");
@@ -1062,6 +1087,9 @@ struct RowViewCore : public IP, C... {
   }
 };
 
+template <typename T>
+concept is_iterator = soa::is_base_of_template_origin_v<RowViewCore, T> || soa::is_specialization_origin_v<T, RowViewCore>;
+
 template <typename, typename = void>
 constexpr bool is_type_with_policy_v = false;
 
@@ -1073,6 +1101,9 @@ struct ArrowHelpers {
   static std::shared_ptr<arrow::Table> concatTables(std::vector<std::shared_ptr<arrow::Table>>&& tables);
 };
 
+template <typename T>
+concept with_base_table = not_void<typename aod::MetadataTrait<T>::metadata::base_table_t>;
+
 template <typename... T>
 using originals_pack_t = decltype(make_originals_from_type(framework::pack<T...>{}));
 
@@ -1096,22 +1127,56 @@ template <typename T, typename B>
 struct is_binding_compatible : std::conditional_t<is_binding_compatible_v<T, typename B::binding_t>(), std::true_type, std::false_type> {
 };
 
+template <o2::framework::OriginEnc ORIGIN, typename Key, typename H, typename... Ts>
+struct IndexTable;
+
 template <typename T>
+concept is_index_table = soa::is_specialization_origin_v<T, o2::soa::IndexTable>;
+
+template <soa::is_table T>
+  requires (!soa::is_index_table<T>)
 static constexpr std::string getLabelFromType()
 {
-  if constexpr (soa::is_index_table_v<std::decay_t<T>>) {
-    using TT = typename std::decay_t<T>::first_t;
-    if constexpr (soa::is_type_with_originals_v<std::decay_t<TT>>) {
-      using O = typename framework::pack_head_t<typename std::decay_t<TT>::originals>;
-      using groupingMetadata = typename aod::MetadataTrait<O>::metadata;
-      return std::string{groupingMetadata::tableLabel()};
+  if constexpr (soa::is_type_with_originals_v<std::decay_t<T>>) {
+    using TT = typename framework::pack_head_t<typename std::decay_t<T>::originals>;
+    if constexpr (soa::with_base_table<typename aod::MetadataTrait<TT>::metadata>) {
+      using TTT = typename aod::MetadataTrait<TT>::metadata::base_table_t;
+      return getLabelFromType<TTT>();
     } else {
       using groupingMetadata = typename aod::MetadataTrait<TT>::metadata;
       return std::string{groupingMetadata::tableLabel()};
     }
-  } else if constexpr (soa::is_type_with_originals_v<std::decay_t<T>>) {
+  } else {
+    if constexpr (soa::with_base_table<typename aod::MetadataTrait<T>::metadata>) {
+      using TT = typename aod::MetadataTrait<T>::metadata::base_table_t;
+      return getLabelFromType<TT>();
+    } else {
+      using groupingMetadata = typename aod::MetadataTrait<std::decay_t<T>>::metadata;
+      return std::string{groupingMetadata::tableLabel()};
+    }
+  }
+}
+
+template <soa::is_index_table T>
+static constexpr std::string getLabelFromType()
+{
+  using TT = typename std::decay_t<T>::first_t;
+  if constexpr (soa::is_type_with_originals_v<std::decay_t<TT>>) {
+    using O = typename framework::pack_head_t<typename std::decay_t<TT>::originals>;
+    using groupingMetadata = typename aod::MetadataTrait<O>::metadata;
+    return std::string{groupingMetadata::tableLabel()};
+  } else {
+    using groupingMetadata = typename aod::MetadataTrait<TT>::metadata;
+    return std::string{groupingMetadata::tableLabel()};
+  }
+}
+
+template <soa::is_iterator T>
+static constexpr std::string getLabelFromType()
+{
+  if constexpr (soa::is_type_with_originals_v<std::decay_t<T>>) {
     using TT = typename framework::pack_head_t<typename std::decay_t<T>::originals>;
-    if constexpr (soa::is_with_base_table_v<typename aod::MetadataTrait<TT>::metadata>) {
+    if constexpr (soa::with_base_table<typename aod::MetadataTrait<TT>::metadata>) {
       using TTT = typename aod::MetadataTrait<TT>::metadata::base_table_t;
       return getLabelFromType<TTT>();
     } else {
@@ -1119,7 +1184,7 @@ static constexpr std::string getLabelFromType()
       return std::string{groupingMetadata::tableLabel()};
     }
   } else {
-    if constexpr (soa::is_with_base_table_v<typename aod::MetadataTrait<T>::metadata>) {
+    if constexpr (soa::with_base_table<typename aod::MetadataTrait<T>::metadata>) {
       using TT = typename aod::MetadataTrait<T>::metadata::base_table_t;
       return getLabelFromType<TT>();
     } else {
@@ -1276,63 +1341,34 @@ using PresliceOptional = PresliceBase<T, true, true>;
 
 namespace o2::soa
 {
-/// special case for the template with origin
-template <typename T, template <o2::framework::OriginEnc, typename...> class Ref>
-struct is_specialization_origin : std::false_type {
-};
-
-template <template <o2::framework::OriginEnc, typename...> class Ref, o2::framework::OriginEnc ORIGIN, typename... Args>
-struct is_specialization_origin<Ref<ORIGIN, Args...>, Ref> : std::true_type {
-};
-
-template <typename T, template <o2::framework::OriginEnc, typename...> class Ref>
-inline constexpr bool is_specialization_origin_v = is_specialization_origin<T, Ref>::value;
-
-template <template <o2::framework::OriginEnc, typename...> class base, typename derived>
-struct is_base_of_template_origin_impl {
-  template <o2::framework::OriginEnc ORIGIN, typename... Ts>
-  static constexpr std::true_type test(const base<ORIGIN, Ts...>*);
-  static constexpr std::false_type test(...);
-  using type = decltype(test(std::declval<derived*>()));
-};
-
-template <template <o2::framework::OriginEnc, typename...> class base, typename derived>
-using is_base_of_template_origin = typename is_base_of_template_origin_impl<base, derived>::type;
+template <typename T>
+using is_soa_table_t = typename soa::is_specialization_origin<T, soa::Table>;
 
-template <template <o2::framework::OriginEnc, typename...> class base, typename derived>
-inline constexpr bool is_base_of_template_origin_v = is_base_of_template_origin<base, derived>::value;
+template <typename T>
+inline constexpr bool is_soa_table_like_v = soa::is_base_of_template_origin_v<soa::Table, T>;
 
-//! Helper to check if a type T is an iterator
 template <typename T>
-inline constexpr bool is_soa_iterator_v = soa::is_base_of_template_origin_v<RowViewCore, T> || soa::is_specialization_origin_v<T, RowViewCore>;
+class FilteredBase;
+template <typename T>
+class Filtered;
 
 template <typename T>
-inline consteval bool is_soa_filtered_iterator_v()
-{
-  if constexpr (!is_soa_iterator_v<T>) {
-    return false;
-  } else {
-    if constexpr (std::is_same_v<typename T::policy_t, soa::FilteredIndexPolicy>) {
-      return true;
-    } else {
-      return false;
-    }
-  }
-}
+inline constexpr bool is_soa_filtered_v = framework::is_base_of_template_v<soa::FilteredBase, T>;
 
 template <typename T>
-using is_soa_table_t = typename soa::is_specialization_origin<T, soa::Table>;
+concept has_filtered_policy = not_void<typename T::policy_t> && std::same_as<typename T::policy_t, soa::FilteredIndexPolicy>;
 
 template <typename T>
-inline constexpr bool is_soa_table_like_v = soa::is_base_of_template_origin_v<soa::Table, T>;
+concept is_filtered_table = framework::is_base_of_template_v<soa::FilteredBase, T>;
 
 template <typename T>
-class FilteredBase;
+concept is_not_filtered_table = is_table<T> && !is_filtered_table<T>;
+
 template <typename T>
-class Filtered;
+concept is_filtered_iterator = is_iterator<T> && has_filtered_policy<T>;
 
 template <typename T>
-inline constexpr bool is_soa_filtered_v = framework::is_base_of_template_v<soa::FilteredBase, T>;
+concept is_filtered = is_filtered_table<T> || is_filtered_iterator<T>;
 
 /// Helper function to extract bound indices
 template <typename... Is>
@@ -1361,7 +1397,7 @@ auto doSliceBy(T const* table, o2::framework::PresliceBase<C, OPT, SORTED> const
       return t;
     } else {
       auto selection = container.getSliceFor(value);
-      if constexpr (soa::is_soa_filtered_v<T>) {
+      if constexpr (soa::is_filtered_table<T>) {
         auto t = soa::Filtered<typename T::base_t>({table->asArrowTable()}, selection);
         table->copyIndexBindings(t);
         t.bindInternalIndicesTo(table);
@@ -1387,7 +1423,7 @@ template <typename T>
 auto prepareFilteredSlice(T const* table, std::shared_ptr<arrow::Table> slice, uint64_t offset)
 {
   if (offset >= static_cast<uint64_t>(table->tableSize())) {
-    if constexpr (soa::is_soa_filtered_v<T>) {
+    if constexpr (soa::is_filtered_table<T>) {
       Filtered<typename T::base_t> fresult{{{slice}}, SelectionVector{}, 0};
       table->copyIndexBindings(fresult);
       return fresult;
@@ -1407,7 +1443,7 @@ auto prepareFilteredSlice(T const* table, std::shared_ptr<arrow::Table> slice, u
                  [&start](int64_t idx) {
                    return idx - static_cast<int64_t>(start);
                  });
-  if constexpr (soa::is_soa_filtered_v<T>) {
+  if constexpr (soa::is_filtered_table<T>) {
     Filtered<typename T::base_t> fresult{{{slice}}, std::move(slicedSelection), start};
     table->copyIndexBindings(fresult);
     return fresult;
@@ -1458,7 +1494,7 @@ template <typename T>
 auto doSliceByCachedUnsorted(T const* table, framework::expressions::BindingNode const& node, int value, o2::framework::SliceCache& cache)
 {
   auto localCache = cache.ptr->getCacheUnsortedFor({o2::soa::getLabelFromTypeForKey<T>(node.name), node.name});
-  if constexpr (soa::is_soa_filtered_v<T>) {
+  if constexpr (soa::is_filtered_table<T>) {
     auto t = typename T::self_t({table->asArrowTable()}, localCache.getSliceFor(value));
     t.intersectWithSelection(table->getSelectedRows());
     table->copyIndexBindings(t);
@@ -1592,7 +1628,7 @@ class Table
         return framework::pack_element_t<idx, external_index_columns_t>::getId();
       } else if constexpr (std::is_same_v<decayed, Parent>) { // self index
         return this->globalIndex();
-      } else if constexpr (is_index_t<decayed>::value && decayed::mLabel == "Index") { // soa::Index<>
+      } else if constexpr (is_indexing_column<decayed>) { // soa::Index<>
         return this->globalIndex();
       } else {
         return static_cast<int32_t>(-1);
@@ -1853,7 +1889,7 @@ class Table
   template <typename T>
   arrow::ChunkedArray* lookupColumn()
   {
-    if constexpr (T::persistent::value) {
+    if constexpr (soa::is_persistent_column<T>) {
       auto label = T::columnLabel();
       return getIndexFromLabel(mTable.get(), label);
     } else {
@@ -1905,6 +1941,9 @@ class TableMetadata
   static std::string sourceSpec() { return fmt::format("{}/{:s}/{}/{}", INHERIT::mLabel, INHERIT::table_t::mOrigin, INHERIT::mDescription, INHERIT::mVersion); };
 };
 
+template <typename T>
+concept is_metadata = framework::is_base_of_template_v<TableMetadata, T>;
+
 /// Helper templates to define universal join and concat
 template <o2::framework::OriginEnc ORIGIN, typename... T>
 constexpr auto join(T const&... t)
@@ -1925,22 +1964,20 @@ void notBoundTable(const char* tableName);
 
 namespace row_helpers
 {
-template <typename... Cs>
+template <soa::is_persistent_column... Cs>
 std::array<arrow::ChunkedArray*, sizeof...(Cs)> getArrowColumns(arrow::Table* table, framework::pack<Cs...>)
 {
-  static_assert(std::conjunction_v<typename Cs::persistent...>, "Arrow columns: only persistent columns accepted (not dynamic and not index ones");
   return std::array<arrow::ChunkedArray*, sizeof...(Cs)>{o2::soa::getIndexFromLabel(table, Cs::columnLabel())...};
 }
 
-template <typename... Cs>
+template <soa::is_persistent_column... Cs>
 std::array<std::shared_ptr<arrow::Array>, sizeof...(Cs)> getChunks(arrow::Table* table, framework::pack<Cs...>, uint64_t ci)
 {
-  static_assert(std::conjunction_v<typename Cs::persistent...>, "Arrow chunks: only persistent columns accepted (not dynamic and not index ones");
   return std::array<std::shared_ptr<arrow::Array>, sizeof...(Cs)>{o2::soa::getIndexFromLabel(table, Cs::columnLabel())->chunk(ci)...};
 }
 
-template <typename T, typename C>
-typename C::type getSingleRowPersistentData(arrow::Table* table, T& rowIterator, uint64_t ci = std::numeric_limits<uint64_t>::max(), uint64_t ai = std::numeric_limits<uint64_t>::max())
+template <typename T, soa::is_persistent_column C>
+typename C::type getSingleRowData(arrow::Table* table, T& rowIterator, uint64_t ci = std::numeric_limits<uint64_t>::max(), uint64_t ai = std::numeric_limits<uint64_t>::max(), uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
 {
   if (ci == std::numeric_limits<uint64_t>::max() || ai == std::numeric_limits<uint64_t>::max()) {
     auto colIterator = static_cast<C>(rowIterator).getIterator();
@@ -1950,8 +1987,8 @@ typename C::type getSingleRowPersistentData(arrow::Table* table, T& rowIterator,
   return std::static_pointer_cast<o2::soa::arrow_array_for_t<typename C::type>>(o2::soa::getIndexFromLabel(table, C::columnLabel())->chunk(ci))->raw_values()[ai];
 }
 
-template <typename T, typename C>
-typename C::type getSingleRowDynamicData(T& rowIterator, uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
+template <typename T, soa::is_dynamic_column C>
+typename C::type getSingleRowData(arrow::Table*, T& rowIterator, uint64_t ci = std::numeric_limits<uint64_t>::max(), uint64_t ai = std::numeric_limits<uint64_t>::max(), uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
 {
   if (globalIndex != std::numeric_limits<uint64_t>::max() && globalIndex != *std::get<0>(rowIterator.getIndices())) {
     rowIterator.setCursor(globalIndex);
@@ -1959,8 +1996,8 @@ typename C::type getSingleRowDynamicData(T& rowIterator, uint64_t globalIndex =
   return rowIterator.template getDynamicColumn<C>();
 }
 
-template <typename T, typename C>
-typename C::type getSingleRowIndexData(T& rowIterator, uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
+template <typename T, soa::is_index_column C>
+typename C::type getSingleRowData(arrow::Table*, T& rowIterator, uint64_t ci = std::numeric_limits<uint64_t>::max(), uint64_t ai = std::numeric_limits<uint64_t>::max(), uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
 {
   if (globalIndex != std::numeric_limits<uint64_t>::max() && globalIndex != *std::get<0>(rowIterator.getIndices())) {
     rowIterator.setCursor(globalIndex);
@@ -1968,21 +2005,6 @@ typename C::type getSingleRowIndexData(T& rowIterator, uint64_t globalIndex = st
   return rowIterator.template getId<C>();
 }
 
-template <typename T, typename C>
-typename C::type getSingleRowData(arrow::Table* table, T& rowIterator, uint64_t ci = -1, uint64_t ai = std::numeric_limits<uint64_t>::max(), uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
-{
-  using decayed = std::decay_t<C>;
-  if constexpr (decayed::persistent::value) {
-    return getSingleRowPersistentData<T, C>(table, rowIterator, ci, ai);
-  } else if constexpr (o2::soa::is_dynamic_t<decayed>()) {
-    return getSingleRowDynamicData<T, C>(rowIterator, globalIndex);
-  } else if constexpr (o2::soa::is_index_t<decayed>::value) {
-    return getSingleRowIndexData<T, C>(rowIterator, globalIndex);
-  } else {
-    static_assert(!sizeof(decayed*), "Unrecognized column kind"); // A trick to delay static_assert until we actually instantiate this branch
-  }
-}
-
 template <typename T, typename... Cs>
 std::tuple<typename Cs::type...> getRowData(arrow::Table* table, T rowIterator, uint64_t ci = std::numeric_limits<uint64_t>::max(), uint64_t ai = std::numeric_limits<uint64_t>::max(), uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
 {
@@ -2298,7 +2320,7 @@ DECLARE_SOA_ITERATOR_METADATA();
     template <typename T>                                                                                \
     std::vector<typename T::iterator> getFilteredIterators() const                                       \
     {                                                                                                    \
-      if constexpr (o2::soa::is_soa_filtered_v<T>) {                                                     \
+      if constexpr (o2::soa::is_filtered_table<T>) {                                                     \
         auto result = std::vector<typename T::iterator>();                                               \
         for (auto const& i : *mColumnIterator) {                                                         \
           auto pos = mBinding.get<T>()->isInSelectedRows(i);                                             \
@@ -3643,20 +3665,4 @@ struct is_smallgroups_t<SmallGroupsBase<T, F>> {
 template <typename T>
 constexpr bool is_smallgroups_v = is_smallgroups_t<T>::value;
 } // namespace o2::soa
-
-namespace o2::framework
-{
-using ListVector = std::vector<std::vector<int64_t>>;
-
-std::string cutString(std::string&& str);
-
-void sliceByColumnGeneric(
-  char const* key,
-  char const* target,
-  std::shared_ptr<arrow::Table> const& input,
-  int32_t fullSize,
-  ListVector* groups,
-  ListVector* unassigned = nullptr);
-} // namespace o2::framework
-
 #endif // O2_FRAMEWORK_ASOA_H_
diff --git a/Framework/Core/include/Framework/ASoAHelpers.h b/Framework/Core/include/Framework/ASoAHelpers.h
index 6d2574cbe0d7f..fb9480e97ddfb 100644
--- a/Framework/Core/include/Framework/ASoAHelpers.h
+++ b/Framework/Core/include/Framework/ASoAHelpers.h
@@ -88,7 +88,7 @@ std::vector<BinningIndex> groupTable(const T& table, const BP<Cs...>& binningPol
     return groupedIndices;
   }
 
-  if constexpr (soa::is_soa_filtered_v<T>) {
+  if constexpr (soa::is_filtered_table<T>) {
     selectedRows = table.getSelectedRows(); // vector<int64_t>
   }
 
@@ -111,7 +111,7 @@ std::vector<BinningIndex> groupTable(const T& table, const BP<Cs...>& binningPol
       }
     });
 
-    if constexpr (soa::is_soa_filtered_v<T>) {
+    if constexpr (soa::is_filtered_table<T>) {
       if (selectedRows[ind] >= selInd + chunkLength) {
         selInd += chunkLength;
         continue; // Go to the next chunk, no value selected in this chunk
@@ -120,7 +120,7 @@ std::vector<BinningIndex> groupTable(const T& table, const BP<Cs...>& binningPol
 
     uint64_t ai = 0;
     while (ai < chunkLength) {
-      if constexpr (soa::is_soa_filtered_v<T>) {
+      if constexpr (soa::is_filtered_table<T>) {
         ai += selectedRows[ind] - selInd;
         selInd = selectedRows[ind];
       }
@@ -132,7 +132,7 @@ std::vector<BinningIndex> groupTable(const T& table, const BP<Cs...>& binningPol
       }
       ind++;
 
-      if constexpr (soa::is_soa_filtered_v<T>) {
+      if constexpr (soa::is_filtered_table<T>) {
         if (ind >= selectedRows.size()) {
           break;
         }
@@ -141,7 +141,7 @@ std::vector<BinningIndex> groupTable(const T& table, const BP<Cs...>& binningPol
       }
     }
 
-    if constexpr (soa::is_soa_filtered_v<T>) {
+    if constexpr (soa::is_filtered_table<T>) {
       if (ind == selectedRows.size()) {
         break;
       }
@@ -1348,7 +1348,7 @@ auto combinations(const BP& binningPolicy, int categoryNeighbours, const T1& out
   }
 }
 
-template <typename... T2s>
+template <soa::is_table... T2s>
 auto combinations(const o2::framework::expressions::Filter& filter, const T2s&... tables)
 {
   if constexpr (isSameType<T2s...>()) {
@@ -1366,7 +1366,7 @@ CombinationsGenerator<P2<T2s...>> combinations(const P2<T2s...>& policy)
   return CombinationsGenerator<P2<T2s...>>(policy);
 }
 
-template <template <typename...> typename P2, typename... T2s>
+template <template <typename...> typename P2, soa::is_table... T2s>
 CombinationsGenerator<P2<Filtered<T2s>...>> combinations(P2<T2s...>&&, const o2::framework::expressions::Filter& filter, const T2s&... tables)
 {
   return CombinationsGenerator<P2<Filtered<T2s>...>>(P2<Filtered<T2s>...>(tables.select(filter)...));
diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index bb549af7bec85..4d373f9a595b1 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -87,7 +87,7 @@ struct WritingCursor<soa::Table<ORIGIN, PC...>> {
   template <typename T>
   static decltype(auto) extract(T const& arg)
   {
-    if constexpr (soa::is_soa_iterator_v<T>) {
+    if constexpr (requires (T t) { t.globalIndex(); }) {
       return arg.globalIndex();
     } else {
       static_assert(!framework::has_type<T>(framework::pack<PC...>{}), "Argument type mismatch");
@@ -103,7 +103,7 @@ struct WritingCursor<soa::Table<ORIGIN, PC...>> {
 };
 
 /// Helper to define output for a Table
-template <typename T>
+template <soa::is_table T>
 struct OutputForTable {
   using table_t = T;
   using metadata = typename aod::MetadataTrait<table_t>::metadata;
@@ -483,14 +483,14 @@ struct Service {
   }
 };
 
-template <typename T>
-auto getTableFromFilter(const T& table, soa::SelectionVector&& selection)
+auto getTableFromFilter(soa::is_filtered_table auto const& table, soa::SelectionVector&& selection)
 {
-  if constexpr (soa::is_soa_filtered_v<std::decay_t<T>>) {
-    return std::make_unique<o2::soa::Filtered<T>>(std::vector{table}, std::forward<soa::SelectionVector>(selection));
-  } else {
-    return std::make_unique<o2::soa::Filtered<T>>(std::vector{table.asArrowTable()}, std::forward<soa::SelectionVector>(selection));
-  }
+  return std::make_unique<o2::soa::Filtered<std::decay_t<decltype(table)>>>(std::vector{table}, std::forward<soa::SelectionVector>(selection));
+}
+
+auto getTableFromFilter(soa::is_not_filtered_table auto const& table, soa::SelectionVector&& selection)
+{
+  return std::make_unique<o2::soa::Filtered<std::decay_t<decltype(table)>>>(std::vector{table.asArrowTable()}, std::forward<soa::SelectionVector>(selection));
 }
 
 void initializePartitionCaches(std::set<uint32_t> const& hashes, std::shared_ptr<arrow::Schema> const& schema, expressions::Filter const& filter, gandiva::NodePtr& tree, gandiva::FilterPtr& gfilter);
@@ -611,20 +611,18 @@ struct Partition {
 namespace o2::soa
 {
 /// On-the-fly adding of expression columns
-template <typename T, typename... Cs>
+template <soa::is_table T, soa::is_spawnable_column... Cs>
 auto Extend(T const& table)
 {
-  static_assert((soa::is_type_spawnable_v<Cs> && ...), "You can only extend a table with expression columns");
   using output_t = Join<T, soa::Table<o2::framework::OriginEnc{"JOIN"}, Cs...>>;
   return output_t{{o2::framework::spawner<o2::framework::OriginEnc{"JOIN"}>(framework::pack<Cs...>{}, {table.asArrowTable()}, "dynamicExtension"), table.asArrowTable()}, 0};
 }
 
 /// Template function to attach dynamic columns on-the-fly (e.g. inside
 /// process() function). Dynamic columns need to be compatible with the table.
-template <typename T, typename... Cs>
+template <soa::is_table T, soa::is_dynamic_column... Cs>
 auto Attach(T const& table)
 {
-  static_assert((framework::is_base_of_template_v<o2::soa::DynamicColumn, Cs> && ...), "You can only attach dynamic columns");
   using output_t = Join<T, o2::soa::Table<o2::framework::OriginEnc{"JOIN"}, Cs...>>;
   return output_t{{table.asArrowTable()}, table.offset()};
 }
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index ec0f5b5067075..b79461fad2a43 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -417,43 +417,6 @@ struct OutputManager<Builds<T>> {
   }
 };
 
-template <typename T>
-class has_instance
-{
-  using one = char;
-  struct two {
-    char x[2];
-  };
-
-  template <typename C>
-  static one test(decltype(&C::instance));
-  template <typename C>
-  static two test(...);
-
- public:
-  enum { value = sizeof(test<T>(nullptr)) == sizeof(char) };
-};
-
-template <typename T>
-class has_end_of_stream
-{
-  using one = char;
-  struct two {
-    char x[2];
-  };
-
-  template <typename C>
-  static one test(decltype(&C::endOfStream));
-  template <typename C>
-  static two test(...);
-
- public:
-  enum { value = sizeof(test<T>(nullptr)) == sizeof(char) };
-};
-
-template <typename T>
-inline constexpr bool has_end_of_stream_v = has_end_of_stream<T>::value;
-
 template <typename T>
 struct ServiceManager {
   template <typename ANY>
@@ -477,7 +440,7 @@ struct ServiceManager {
 
 template <typename T>
 struct ServiceManager<Service<T>> {
-  static bool add(std::vector<ServiceSpec>& specs, Service<T>& service)
+  static bool add(std::vector<ServiceSpec>& specs, Service<T>& /*service*/)
   {
     if constexpr (o2::framework::is_base_of_template_v<LoadableServicePlugin, T>) {
       T p = T{};
@@ -489,7 +452,7 @@ struct ServiceManager<Service<T>> {
 
   static bool prepare(InitContext& context, Service<T>& service)
   {
-    if constexpr (has_instance<T>::value) {
+    if constexpr (requires { T::instance(); }) {
       service.service = &(T::instance()); // Sigh...
       return true;
     } else {
@@ -500,11 +463,11 @@ struct ServiceManager<Service<T>> {
   }
 
   /// If a service has a method endOfStream, it is called at the end of the stream.
-  static bool postRun(EndOfStreamContext& context, Service<T>& service)
+  static bool postRun(EndOfStreamContext& /*context*/, Service<T>& service)
   {
     // FIXME: for the moment we only need endOfStream to be
     // stateless. In the future we might want to pass it EndOfStreamContext
-    if constexpr (has_end_of_stream_v<T>) {
+    if constexpr (requires(T t) { t.endOfStream(); }) {
       service.service->endOfStream();
       return true;
     }
@@ -637,7 +600,7 @@ struct SpawnManager {
   static bool requestInputs(std::vector<InputSpec>&, T const&) { return false; }
 };
 
-template <typename TABLE>
+template <soa::is_table TABLE>
 struct SpawnManager<Spawns<TABLE>> {
   static bool requestInputs(std::vector<InputSpec>& inputs, Spawns<TABLE>& spawns)
   {
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index ea57b643fadb2..738de1c0606e1 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -58,6 +58,9 @@ static constexpr bool is_enumeration_v = false;
 template <int64_t BEGIN, int64_t END, int64_t STEP>
 static constexpr bool is_enumeration_v<Enumeration<BEGIN, END, STEP>> = true;
 
+template <typename T>
+concept is_enumeration = is_enumeration_v<T>;
+
 // Helper struct which builds a DataProcessorSpec from
 // the contents of an AnalysisTask...
 namespace {
@@ -65,7 +68,7 @@ struct AnalysisDataProcessorBuilder {
   template <typename T>
   static ConfigParamSpec getSpec()
   {
-    if constexpr (soa::is_type_with_metadata_v<aod::MetadataTrait<T>>) {
+    if constexpr (soa::has_metadata<aod::MetadataTrait<T>>) {
       return ConfigParamSpec{std::string{"input:"} + aod::MetadataTrait<T>::metadata::tableLabel(), VariantType::String, aod::MetadataTrait<T>::metadata::sourceSpec(), {"\"\""}};
     } else {
       using O1 = framework::pack_element_t<0, typename T::originals>;
@@ -79,8 +82,8 @@ struct AnalysisDataProcessorBuilder {
     return std::vector{getSpec<T>()...};
   }
 
-  template <typename T>
-  static inline auto getSources() requires soa::is_soa_index_table_v<std::decay_t<T>>
+  template <soa::is_index_table T>
+  static inline auto getSources()
   {
     return getInputSpecs(typename T::sources_t{});
   }
@@ -123,12 +126,12 @@ struct AnalysisDataProcessorBuilder {
   }
 
   template <typename O>
-  static void addOriginal(const char* name, bool value, std::vector<InputSpec>& inputs) requires soa::is_type_with_metadata_v<aod::MetadataTrait<std::decay_t<O>>>
+  static void addOriginal(const char* name, bool value, std::vector<InputSpec>& inputs) requires soa::has_metadata<aod::MetadataTrait<std::decay_t<O>>>
   {
     using metadata = typename aod::MetadataTrait<std::decay_t<O>>::metadata;
     std::vector<ConfigParamSpec> inputMetadata;
     inputMetadata.emplace_back(ConfigParamSpec{std::string{"control:"} + name, VariantType::Bool, value, {"\"\""}});
-    if constexpr (soa::is_soa_index_table_v<std::decay_t<O>> || soa::is_soa_extension_table_v<std::decay_t<O>>) {
+    if constexpr (soa::is_index_table<std::decay_t<O>> || soa::is_soa_extension_table_v<std::decay_t<O>>) {
       auto inputSources = getInputMetadata<std::decay_t<O>>();
       inputMetadata.insert(inputMetadata.end(), inputSources.begin(), inputSources.end());
     }
@@ -139,7 +142,7 @@ struct AnalysisDataProcessorBuilder {
   static void inputsFromArgs(R (C::*)(Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos, std::vector<StringPair>& bk, std::vector<StringPair>& bku) requires(std::is_lvalue_reference_v<Args>&&...)
   {
     // update grouping cache
-    if constexpr (soa::is_soa_iterator_v<std::decay_t<framework::pack_element_t<0, framework::pack<Args...>>>>) {
+    if constexpr (soa::is_iterator<std::decay_t<framework::pack_element_t<0, framework::pack<Args...>>>>) {
       addGroupingCandidates<Args...>(bk, bku);
     }
 
@@ -149,16 +152,16 @@ struct AnalysisDataProcessorBuilder {
     ([&name, &value, &eInfos, &inputs, &hash, &ai]() mutable {
       ++ai;
       using T = std::decay_t<Args>;
-      if constexpr (is_enumeration_v<T>) {
+      if constexpr (is_enumeration<T>) {
         std::vector<ConfigParamSpec> inputMetadata;
         // FIXME: for the moment we do not support begin, end and step.
         DataSpecUtils::updateInputList(inputs, InputSpec{"enumeration", "DPL", "ENUM", 0, Lifetime::Enumeration, inputMetadata});
       } else {
         // populate expression infos
-        if constexpr (soa::is_soa_filtered_v<T>) {
+        if constexpr (soa::is_filtered_table<T>) {
           auto fields = soa::createFieldsFromColumns(typename T::persistent_columns_t{});
           eInfos.emplace_back(ai, hash, T::hashes(), std::make_shared<arrow::Schema>(fields));
-        } else if constexpr (soa::is_soa_filtered_iterator_v<T>()) {
+        } else if constexpr (soa::is_filtered_iterator<T>) {
           auto fields = soa::createFieldsFromColumns(typename T::parent_t::persistent_columns_t{});
           eInfos.emplace_back(ai, hash, T::parent_t::hashes(), std::make_shared<arrow::Schema>(fields));
         }
@@ -173,7 +176,7 @@ struct AnalysisDataProcessorBuilder {
   }
 
   template <typename T>
-  static auto extractTableFromRecord(InputRecord& record) requires soa::is_type_with_metadata_v<aod::MetadataTrait<T>>
+  static auto extractTableFromRecord(InputRecord& record) requires soa::has_metadata<aod::MetadataTrait<T>>
   {
     auto table = record.get<TableConsumer>(aod::MetadataTrait<T>::metadata::tableLabel())->asArrowTable();
     if (table->num_rows() == 0) {
@@ -188,17 +191,19 @@ struct AnalysisDataProcessorBuilder {
     return extractFromRecord<T>(record, typename T::originals{});
   }
 
-  template <typename T, typename... Os>
-  static auto extractFromRecord(InputRecord& record, pack<Os...> const&)
+  template <soa::is_table T, typename... Os>
+  static auto extractFromRecord(InputRecord& record, pack<Os...>)
   {
-    if constexpr (soa::is_soa_iterator_v<T>) {
-      return typename T::parent_t{{extractTableFromRecord<Os>(record)...}};
-    } else {
-      return T{{extractTableFromRecord<Os>(record)...}};
-    }
+    return T{{extractTableFromRecord<Os>(record)...}};
+  }
+
+  template <soa::is_iterator T, typename... Os>
+  static auto extractFromRecord(InputRecord& record, pack<Os...>)
+  {
+    return typename T::parent_t{{extractTableFromRecord<Os>(record)...}};
   }
 
-  template <typename T, typename... Os>
+  template <soa::is_filtered T, typename... Os>
   static auto extractFilteredFromRecord(InputRecord& record, ExpressionInfo& info, pack<Os...> const&)
   {
     auto table = o2::soa::ArrowHelpers::joinTables(std::vector<std::shared_ptr<arrow::Table>>{extractTableFromRecord<Os>(record)...});
@@ -208,21 +213,21 @@ struct AnalysisDataProcessorBuilder {
         soa::missingFilterDeclaration(info.processHash, info.argumentIndex);
       }
     }
-    if constexpr (soa::is_soa_iterator_v<T>) {
+    if constexpr (soa::is_iterator<T>) {
       return typename T::parent_t({table}, info.selection);
     } else {
       return T({table}, info.selection);
     }
   }
 
-  template <typename T, int AI>
-  static auto extract(InputRecord&, std::vector<ExpressionInfo>&, size_t) requires is_enumeration_v<T>
+  template <is_enumeration T, int AI>
+  static auto extract(InputRecord&, std::vector<ExpressionInfo>&, size_t)
   {
     return T{};
   }
 
-  template <typename T, int AI>
-  static auto extract(InputRecord& record, std::vector<ExpressionInfo>& infos, size_t phash) requires soa::is_soa_iterator_v<T>
+  template <soa::is_iterator T, int AI>
+  static auto extract(InputRecord& record, std::vector<ExpressionInfo>& infos, size_t phash)
   {
     if constexpr (std::is_same_v<typename T::policy_t, soa::FilteredIndexPolicy>) {
       return extractFilteredFromRecord<T>(record, *std::find_if(infos.begin(), infos.end(), [&phash](ExpressionInfo const& i) { return (i.processHash == phash && i.argumentIndex == AI); }), soa::make_originals_from_type<T>());
@@ -231,10 +236,10 @@ struct AnalysisDataProcessorBuilder {
     }
   }
 
-  template <typename T, int AI>
-  static auto extract(InputRecord& record, std::vector<ExpressionInfo>& infos, size_t phash) requires soa::is_soa_table_like_v<T>
+  template <soa::is_table T, int AI>
+  static auto extract(InputRecord& record, std::vector<ExpressionInfo>& infos, size_t phash)
   {
-    if constexpr (soa::is_soa_filtered_v<T>) {
+    if constexpr (soa::is_filtered_table<T>) {
       return extractFilteredFromRecord<T>(record, *std::find_if(infos.begin(), infos.end(), [&phash](ExpressionInfo const& i) { return (i.processHash == phash && i.argumentIndex == AI); }), soa::make_originals_from_type<T>());
     } else {
       return extractFromRecord<T>(record, soa::make_originals_from_type<T>());
@@ -242,14 +247,16 @@ struct AnalysisDataProcessorBuilder {
   }
 
   template <typename R, typename C, typename Grouping, typename... Args>
-  static auto bindGroupingTable(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos) requires(!std::is_same_v<Grouping, void> || sizeof...(Args) > 0)
+  static auto bindGroupingTable(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
+    requires(!std::is_same_v<Grouping, void> || sizeof...(Args) > 0)
   {
     constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Grouping, Args...)>();
     return extract<std::decay_t<Grouping>, 0>(record, infos, hash);
   }
 
   template <typename R, typename C, typename Grouping, typename... Args>
-  static auto bindAssociatedTables(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos) requires(!std::is_same_v<Grouping, void> || sizeof...(Args) > 0)
+  static auto bindAssociatedTables(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
+    requires(!std::is_same_v<Grouping, void> || sizeof...(Args) > 0)
   {
     constexpr auto p = pack<Args...>{};
     constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Grouping, Args...)>();
@@ -284,18 +291,18 @@ struct AnalysisDataProcessorBuilder {
         return true;
       },
                              task);
-      if constexpr (soa::is_soa_iterator_v<G>) {
+      if constexpr (soa::is_iterator<G>) {
         for (auto& element : groupingTable) {
           std::invoke(processingFunction, task, *element);
         }
       } else {
-        static_assert(soa::is_soa_table_like_v<G> || is_enumeration_v<G>,
+        static_assert(soa::is_table<G> || is_enumeration<G>,
                       "Single argument of process() should be a table-like or an iterator");
         std::invoke(processingFunction, task, groupingTable);
       }
     } else {
       // multiple arguments to process
-      static_assert(((soa::is_soa_iterator_v<std::decay_t<Associated>> == false) && ...),
+      static_assert(((soa::is_iterator<std::decay_t<Associated>> == false) && ...),
                     "Associated arguments of process() should not be iterators");
       auto associatedTables = AnalysisDataProcessorBuilder::bindAssociatedTables(inputs, processingFunction, infos);
       // pre-bind self indices
@@ -336,7 +343,7 @@ struct AnalysisDataProcessorBuilder {
       },
                              task);
       overwriteInternalIndices(associatedTables, associatedTables);
-      if constexpr (soa::is_soa_iterator_v<std::decay_t<G>>) {
+      if constexpr (soa::is_iterator<std::decay_t<G>>) {
         auto slicer = GroupSlicer(groupingTable, associatedTables, slices);
         for (auto& slice : slicer) {
           auto associatedSlices = slice.associatedTables();
diff --git a/Framework/Core/include/Framework/BinningPolicy.h b/Framework/Core/include/Framework/BinningPolicy.h
index 1ac2375ea6d4d..ffd2d0c0360d0 100644
--- a/Framework/Core/include/Framework/BinningPolicy.h
+++ b/Framework/Core/include/Framework/BinningPolicy.h
@@ -12,6 +12,7 @@
 #ifndef FRAMEWORK_BINNINGPOLICY_H
 #define FRAMEWORK_BINNINGPOLICY_H
 
+#include "Framework/ASoA.h"
 #include "Framework/HistogramSpec.h" // only for VARIABLE_WIDTH
 #include "Framework/Pack.h"
 #include "Framework/ArrowTypes.h"
diff --git a/Framework/Core/include/Framework/ConfigParamRegistry.h b/Framework/Core/include/Framework/ConfigParamRegistry.h
index 397a491be9f9c..fdd1cad1de477 100644
--- a/Framework/Core/include/Framework/ConfigParamRegistry.h
+++ b/Framework/Core/include/Framework/ConfigParamRegistry.h
@@ -90,11 +90,11 @@ class ConfigParamRegistry
         return mStore->store().get<std::string>(key);
       } else if constexpr (std::is_same_v<T, std::string_view>) {
         return std::string_view{mStore->store().get<std::string>(key)};
-      } else if constexpr (is_base_of_template_v<std::vector, T>) {
+      } else if constexpr (base_of_template<std::vector, T>) {
         return vectorFromBranch<typename T::value_type>(mStore->store().get_child(key));
-      } else if constexpr (is_base_of_template_v<o2::framework::Array2D, T>) {
+      } else if constexpr (base_of_template<o2::framework::Array2D, T>) {
         return array2DFromBranch<typename T::element_t>(mStore->store().get_child(key));
-      } else if constexpr (is_base_of_template_v<o2::framework::LabeledArray, T>) {
+      } else if constexpr (base_of_template<o2::framework::LabeledArray, T>) {
         return labeledArrayFromBranch<typename T::element_t>(mStore->store().get_child(key));
       } else if constexpr (std::is_same_v<T, boost::property_tree::ptree>) {
         return mStore->store().get_child(key);
diff --git a/Framework/Core/include/Framework/GroupSlicer.h b/Framework/Core/include/Framework/GroupSlicer.h
index 2f94f6e7623a0..a53f70d46015b 100644
--- a/Framework/Core/include/Framework/GroupSlicer.h
+++ b/Framework/Core/include/Framework/GroupSlicer.h
@@ -69,7 +69,7 @@ struct GroupSlicer {
     template <typename T>
     auto extractingFunction(T&& table)
     {
-      if constexpr (soa::is_soa_filtered_v<std::decay_t<T>>) {
+      if constexpr (soa::is_filtered_table<std::decay_t<T>>) {
         constexpr auto index = framework::has_type_at_v<std::decay_t<T>>(associated_pack_t{});
         selections[index] = &table.getSelectedRows();
         starts[index] = selections[index]->begin();
@@ -84,7 +84,7 @@ struct GroupSlicer {
         position{0},
         mSlices{&slices}
     {
-      if constexpr (soa::is_soa_filtered_v<std::decay_t<G>>) {
+      if constexpr (soa::is_filtered_table<std::decay_t<G>>) {
         groupSelection = mGt->getSelectedRows();
       }
 
@@ -159,7 +159,7 @@ struct GroupSlicer {
 
       if constexpr (o2::soa::relatedByIndex<std::decay_t<G>, std::decay_t<A1>>()) {
         uint64_t pos;
-        if constexpr (soa::is_soa_filtered_v<std::decay_t<G>>) {
+        if constexpr (soa::is_filtered_table<std::decay_t<G>>) {
           pos = groupSelection[position];
         } else {
           pos = position;
@@ -173,7 +173,7 @@ struct GroupSlicer {
           auto oc = sliceInfos[index].getSliceFor(pos);
           uint64_t offset = oc.first;
           auto count = oc.second;
-          if constexpr (soa::is_soa_filtered_v<std::decay_t<A1>>) {
+          if constexpr (soa::is_filtered_table<std::decay_t<A1>>) {
             auto groupedElementsTable = originalTable.asArrowTable()->Slice(offset, count);
             if (count == 0) {
               return std::decay_t<A1>{{groupedElementsTable}, soa::SelectionVector{}};
@@ -200,7 +200,7 @@ struct GroupSlicer {
           }
         } else {
           // generic split
-          if constexpr (soa::is_soa_filtered_v<std::decay_t<A1>>) {
+          if constexpr (soa::is_filtered_table<std::decay_t<A1>>) {
             auto selection = sliceInfosUnsorted[index].getSliceFor(pos);
             // intersect selections
             o2::soa::SelectionVector s;
diff --git a/Framework/Core/include/Framework/GroupedCombinations.h b/Framework/Core/include/Framework/GroupedCombinations.h
index f88a534cc9727..963f47cefe40d 100644
--- a/Framework/Core/include/Framework/GroupedCombinations.h
+++ b/Framework/Core/include/Framework/GroupedCombinations.h
@@ -70,7 +70,7 @@ struct GroupedCombinationsGenerator {
         mIndexColumns{getMatchingIndexNode<G, As>()...},
         cache{cache_}
     {
-      if constexpr (soa::is_soa_filtered_v<std::decay_t<G>>) {
+      if constexpr (soa::is_filtered_table<std::decay_t<G>>) {
         mGrouping = std::make_shared<G>(std::vector{grouping.asArrowTable()}, grouping.getSelectedRows());
       } else {
         mGrouping = std::make_shared<G>(std::vector{grouping.asArrowTable()});
@@ -88,7 +88,7 @@ struct GroupedCombinationsGenerator {
     template <typename... T2s>
     void setTables(const G& grouping, const std::tuple<T2s...>& associated)
     {
-      if constexpr (soa::is_soa_filtered_v<std::decay_t<G>>) {
+      if constexpr (soa::is_filtered_table<std::decay_t<G>>) {
         mGrouping = std::make_shared<G>(std::vector{grouping.asArrowTable()}, grouping.getSelectedRows());
       } else {
         mGrouping = std::make_shared<G>(std::vector{grouping.asArrowTable()});
diff --git a/Framework/Core/src/ASoA.cxx b/Framework/Core/src/ASoA.cxx
index f04a0027ee498..e652e1b7aab2d 100644
--- a/Framework/Core/src/ASoA.cxx
+++ b/Framework/Core/src/ASoA.cxx
@@ -149,36 +149,4 @@ std::string cutString(std::string&& str)
   }
   return str;
 }
-
-void sliceByColumnGeneric(
-  char const* key,
-  char const* target,
-  std::shared_ptr<arrow::Table> const& input,
-  int32_t fullSize,
-  ListVector* groups,
-  ListVector* unassigned)
-{
-  groups->resize(fullSize);
-  auto column = input->GetColumnByName(key);
-  int32_t row = 0;
-  for (auto iChunk = 0; iChunk < column->num_chunks(); ++iChunk) {
-    auto chunk = static_cast<arrow::NumericArray<arrow::Int32Type>>(column->chunk(iChunk)->data());
-    for (auto iElement = 0; iElement < chunk.length(); ++iElement) {
-      auto v = chunk.Value(iElement);
-      if (v >= 0) {
-        if (v >= groups->size()) {
-          throw runtime_error_f("Table %s has an entry with index (%d) that is larger than the grouping table size (%d)", target, v, fullSize);
-        }
-        (*groups)[v].push_back(row);
-      } else if (unassigned != nullptr) {
-        auto av = std::abs(v);
-        if (unassigned->size() < av + 1) {
-          unassigned->resize(av + 1);
-        }
-        (*unassigned)[av].push_back(row);
-      }
-      ++row;
-    }
-  }
-}
 } // namespace o2::framework
diff --git a/Framework/Foundation/include/Framework/Pack.h b/Framework/Foundation/include/Framework/Pack.h
index 89555ee45f20c..c8aca060bc3b7 100644
--- a/Framework/Foundation/include/Framework/Pack.h
+++ b/Framework/Foundation/include/Framework/Pack.h
@@ -33,7 +33,7 @@ constexpr std::size_t pack_size(pack<Ts...> const&)
 template <std::size_t I, typename T>
 struct pack_element;
 
-#ifdef __clang__
+#if __has_builtin(__type_pack_element)
 template <std::size_t I, typename... Ts>
 struct pack_element<I, pack<Ts...>> {
   using type = __type_pack_element<I, Ts...>;
@@ -258,40 +258,30 @@ constexpr size_t has_type_at_conditional(pack<T1, Ts...>&&)
   return sizeof...(Ts) + 2;
 }
 
-namespace
+template <typename T, typename... Ts>
+consteval size_t has_type_at_v(pack<Ts...>)
 {
-template <std::size_t I, typename T>
-struct indexed {
-  using type = T;
-  constexpr static std::size_t index = I;
-};
-
-template <typename Is, typename... Ts>
-struct indexer;
-
-template <std::size_t... Is, typename... Ts>
-struct indexer<std::index_sequence<Is...>, Ts...>
-  : indexed<Is, Ts>... {
-};
-
-template <typename T, std::size_t I>
-indexed<I, T> select(indexed<I, T>);
-
-template <typename W, typename... Ts>
-constexpr std::size_t has_type_at_t = decltype(select<W>(
-  indexer<std::index_sequence_for<Ts...>, Ts...>{}))::index;
-} // namespace
-
-template <typename W>
-constexpr std::size_t has_type_at_v(o2::framework::pack<>)
-{
-  return -1;
+  constexpr size_t size = sizeof...(Ts);
+  constexpr bool found[size] = {std::same_as<T, Ts>...};
+  for (size_t i = 0; i < size; ++i) {
+    if (found[i]) {
+      return i;
+    }
+  }
+  return size + 1;
 }
 
-template <typename W, typename... Ts>
-constexpr std::size_t has_type_at_v(o2::framework::pack<Ts...>)
+template <template <typename, typename> typename Condition, typename T, typename... Ts>
+consteval size_t has_type_at_conditional_v(pack<Ts...>)
 {
-  return has_type_at_t<W, Ts...>;
+  constexpr size_t size = sizeof...(Ts);
+  constexpr bool found[size] = {Condition<T, Ts>::value...};
+  for (size_t i = 0; i < size; ++i) {
+    if (found[i]) {
+      return i;
+    }
+  }
+  return size + 1;
 }
 
 /// Intersect two packs
@@ -347,6 +337,12 @@ constexpr auto concatenate_pack_unique(pack<Args1...>, pack<Args2...>)
   return concatenate_pack(p1{}, pack<Args2...>{});
 }
 
+template <typename P1>
+constexpr auto concatenate_pack_unique(P1 p1)
+{
+  return p1;
+}
+
 template <typename P1, typename P2, typename... Ps>
 constexpr auto concatenate_pack_unique(P1 p1, P2 p2, Ps... ps)
 {
diff --git a/Framework/Foundation/include/Framework/Traits.h b/Framework/Foundation/include/Framework/Traits.h
index 999e02dba02c1..ad992ddc9c3ef 100644
--- a/Framework/Foundation/include/Framework/Traits.h
+++ b/Framework/Foundation/include/Framework/Traits.h
@@ -12,6 +12,7 @@
 #define O2_FRAMEWORK_TRAITS_H_
 
 #include <type_traits>
+#include <concepts>
 
 namespace o2::framework
 {
@@ -30,6 +31,13 @@ struct is_specialization<Ref<Args...>, Ref> : std::true_type {
 template <typename T, template <typename...> class Ref>
 inline constexpr bool is_specialization_v = is_specialization<T, Ref>::value;
 
+template <template <typename...> typename T, typename S>
+concept specialization_of_template = requires {
+  {
+    []<typename... Ts>(T<Ts...>*) -> T<Ts...> {}(std::declval<S*>())
+  } -> std::same_as<S>;
+};
+
 template <typename A, typename B>
 struct is_overriding : public std::bool_constant<std::is_same_v<A, B> == false && std::is_member_function_pointer_v<A> && std::is_member_function_pointer_v<B>> {
 };
@@ -41,19 +49,13 @@ struct always_static_assert : std::false_type {
 template <typename... T>
 inline constexpr bool always_static_assert_v = always_static_assert<T...>::value;
 
-template <template <typename...> class base, typename derived>
-struct is_base_of_template_impl {
-  template <typename... Ts>
-  static constexpr std::true_type test(const base<Ts...>*);
-  static constexpr std::false_type test(...);
-  using type = decltype(test(std::declval<derived*>()));
+template <template <typename...> typename B, typename D>
+concept base_of_template = requires {
+  []<typename... Ts>(B<Ts...>*) {}(std::declval<D*>());
 };
 
-template <template <typename...> class base, typename derived>
-using is_base_of_template = typename is_base_of_template_impl<base, derived>::type;
-
-template <template <typename...> class base, typename derived>
-inline constexpr bool is_base_of_template_v = is_base_of_template<base, derived>::value;
+template <template <typename...> typename B, typename D>
+constexpr bool is_base_of_template_v = base_of_template<B, D>;
 
 } // namespace o2::framework
 
diff --git a/Framework/Foundation/test/test_FunctionalHelpers.cxx b/Framework/Foundation/test/test_FunctionalHelpers.cxx
index 895133ae6428d..29912dac56181 100644
--- a/Framework/Foundation/test/test_FunctionalHelpers.cxx
+++ b/Framework/Foundation/test/test_FunctionalHelpers.cxx
@@ -37,10 +37,10 @@ TEST_CASE("TestOverride")
   static_assert(has_type_conditional_v<std::is_same, double, pack<int, float>> == false, "double should not be in the pack");
 
   pack<float, char, int, bool> pck;
-  static_assert(has_type_at<int>(pck) == 2, "int should be at 2");
-  static_assert(has_type_at<double>(pck) == pack_size(pck) + 1, "double is not in the pack so the function returns size + 1");
-  static_assert(has_type_at_conditional<std::is_same, bool>(pack<int, float, bool>()) == 2, "bool should be at 2");
-  static_assert(has_type_at_conditional<std::is_same, bool>(pack<int, float, double>()) == 3 + 1, "bool is not in the pack so the function returns size + 1");
+  static_assert(has_type_at_v<int>(pck) == 2, "int should be at 2");
+  static_assert(has_type_at_v<double>(pck) == pack_size(pck) + 1, "double is not in the pack so the function returns size + 1");
+  static_assert(has_type_at_conditional_v<std::is_same, bool>(pack<int, float, bool>()) == 2, "bool should be at 2");
+  static_assert(has_type_at_conditional_v<std::is_same, bool>(pack<int, float, double>()) == 3 + 1, "bool is not in the pack so the function returns size + 1");
 
   static_assert(std::is_same_v<selected_pack<is_int_t, int, float, char>, pack<int>>, "selector should select int");
   static_assert(std::is_same_v<selected_pack<is_int_t, int, int, float, char>, pack<int, int>>, "selector should select int");