From 41527616c00e943b609f8e9bee6d90e63c7d179f Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Wed, 22 Jan 2025 13:33:10 +0100
Subject: [PATCH 01/20] remove obsolete concept

---
 Framework/Core/include/Framework/ASoA.h | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index e098cd89f6d5d..ccc253850296e 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -814,9 +814,6 @@ concept is_dynamic_column = requires(C& c) {
 template <typename C>
 concept is_marker_column = requires { &C::mark; };
 
-template <typename T>
-using is_dynamic_t = std::conditional_t<is_dynamic_column<T>, std::true_type, std::false_type>;
-
 template <typename T>
 concept is_column = is_persistent_column<T> || is_dynamic_column<T> || is_indexing_column<T> || is_marker_column<T>;
 
@@ -1831,20 +1828,17 @@ class Table
       }
     }
 
-    template <typename CD, typename... CDArgs>
+    template <soa::is_dynamic_column CD, typename... CDArgs>
     auto getDynamicColumn() const
     {
-      using decayed = std::decay_t<CD>;
-      static_assert(is_dynamic_t<decayed>(), "Requested column is not a dynamic column");
-      return static_cast<decayed>(*this).template getDynamicValue<CDArgs...>();
+      return static_cast<std::decay_t<CD>>(*this).template getDynamicValue<CDArgs...>();
     }
 
     template <typename B, typename CC>
+      requires(is_dynamic_column<CC> || is_persistent_column<CC>)
     auto getValue() const
     {
-      using COL = std::decay_t<CC>;
-      static_assert(is_dynamic_t<COL>() || soa::is_persistent_column<COL>, "Should be persistent or dynamic column with no argument that has a return type convertable to float");
-      return static_cast<B>(static_cast<COL>(*this).get());
+      return static_cast<B>(static_cast<std::decay_t<CC>>(*this).get());
     }
 
     template <typename B, typename... CCs>

From 9a6f531571b212d35009c2f490f6e661ae37582d Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 23 Jan 2025 13:05:41 +0100
Subject: [PATCH 02/20] DPL Analysis: remove unnecessary instances of
 selected_pack

---
 Framework/Core/include/Framework/ASoA.h       | 61 +++++++++++--------
 .../include/Framework/GroupedCombinations.h   | 19 +++++-
 2 files changed, 50 insertions(+), 30 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index ccc253850296e..18f20cd177387 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -213,8 +213,6 @@ template <typename D, typename... Cs>
 struct TableMetadata {
   using columns = framework::pack<Cs...>;
   using persistent_columns_t = framework::selected_pack<soa::is_persistent_column_t, Cs...>;
-  using external_index_columns_t = framework::selected_pack<soa::is_external_index_t, Cs...>;
-  using internal_index_columns_t = framework::selected_pack<soa::is_self_index_t, Cs...>;
 
   template <typename Key, typename... PCs>
   static consteval std::array<bool, sizeof...(PCs)> getMap(framework::pack<PCs...>)
@@ -1036,6 +1034,13 @@ concept can_bind = requires(T&& t) {
 template <typename... C>
 concept has_index = (is_indexing_column<C> || ...);
 
+template <is_index_column C>
+  requires (!is_self_index_column<C>)
+auto getBinding() -> typename C::binding_t {}
+
+template <typename C>
+auto getBinding() -> void {}
+
 template <typename D, typename O, typename IP, typename... C>
 struct TableIterator : IP, C... {
  public:
@@ -1043,9 +1048,9 @@ struct TableIterator : IP, C... {
   using policy_t = IP;
   using all_columns = framework::pack<C...>;
   using persistent_columns_t = framework::selected_pack<soa::is_persistent_column_t, C...>;
-  using external_index_columns_t = framework::selected_pack<soa::is_external_index_t, C...>;
-  using internal_index_columns_t = framework::selected_pack<soa::is_self_index_t, C...>;
-  using bindings_pack_t = decltype([]<typename... Cs>(framework::pack<Cs...>) -> framework::pack<typename Cs::binding_t...> {}(external_index_columns_t{})); // decltype(extractBindings(external_index_columns_t{}));
+  using bindings_pack_t = decltype([]<typename... Cs>(framework::pack<Cs...>) {
+    return framework::pack<decltype(getBinding<Cs>())...>{};
+  }(all_columns{}));
 
   TableIterator(arrow::ChunkedArray* columnData[sizeof...(C)], IP&& policy)
     : IP{policy},
@@ -1138,7 +1143,7 @@ struct TableIterator : IP, C... {
   template <typename... CL, typename TA>
   void doSetCurrentIndex(framework::pack<CL...>, TA* current)
   {
-    (CL::setCurrent(current), ...);
+    ([&current, this](){ if constexpr (is_index_column<CL> && !is_self_index_column<CL>) {CL::setCurrent(current);} }(), ...);
   }
 
   template <typename CL>
@@ -1150,24 +1155,30 @@ struct TableIterator : IP, C... {
   template <typename... Cs>
   auto getIndexBindingsImpl(framework::pack<Cs...>) const
   {
-    return std::vector<o2::soa::Binding>{static_cast<Cs const&>(*this).getCurrentRaw()...};
+    std::vector<o2::soa::Binding> result;
+    ([this, &result](){
+      if constexpr (is_index_column<Cs> && !is_self_index_column<Cs>) {
+        result.emplace_back(static_cast<Cs const&>(*this).getCurrentRaw());
+      }
+    }(), ...);
+    return result;
   }
 
   auto getIndexBindings() const
   {
-    return getIndexBindingsImpl(external_index_columns_t{});
+    return getIndexBindingsImpl(all_columns{});
   }
 
   template <typename... TA>
   void bindExternalIndices(TA*... current)
   {
-    (doSetCurrentIndex(external_index_columns_t{}, current), ...);
+    (doSetCurrentIndex(all_columns{}, current), ...);
   }
 
   template <typename... Cs>
   void doSetCurrentIndexRaw(framework::pack<Cs...> p, std::vector<o2::soa::Binding>&& ptrs)
   {
-    (Cs::setCurrentRaw(ptrs[framework::has_type_at_v<Cs>(p)]), ...);
+    ([&ptrs, p, this](){ if constexpr (is_index_column<Cs> && !is_self_index_column<Cs>) { Cs::setCurrentRaw(ptrs[framework::has_type_at_v<Cs>(p)]); } }(), ...);
   }
 
   template <typename... Cs, typename I>
@@ -1175,18 +1186,18 @@ struct TableIterator : IP, C... {
   {
     o2::soa::Binding b;
     b.bind(ptr);
-    (Cs::setCurrentRaw(b), ...);
+    ([&ptr, &b, this](){ if constexpr (is_self_index_column<Cs>) { Cs::setCurrentRaw(b); } }(), ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
   {
-    doSetCurrentIndexRaw(external_index_columns_t{}, std::forward<std::vector<o2::soa::Binding>>(ptrs));
+    doSetCurrentIndexRaw(all_columns{}, std::forward<std::vector<o2::soa::Binding>>(ptrs));
   }
 
   template <typename I>
   void bindInternalIndices(I const* table)
   {
-    doSetCurrentInternal(internal_index_columns_t{}, table);
+    doSetCurrentInternal(all_columns{}, table);
   }
 
  private:
@@ -1370,25 +1381,25 @@ static constexpr std::string getLabelFromTypeForKey(std::string const& key)
 template <typename B, typename... C>
 consteval static bool hasIndexTo(framework::pack<C...>&&)
 {
-  return (o2::soa::is_binding_compatible_v<B, typename C::binding_t>() || ...);
+  return ([](){ if constexpr (is_index_column<C> && !is_self_index_column<C>) { return o2::soa::is_binding_compatible_v<B, typename C::binding_t>(); } else { return false; } }() || ...);
 }
 
 template <typename B, typename... C>
 consteval static bool hasSortedIndexTo(framework::pack<C...>&&)
 {
-  return ((C::sorted && o2::soa::is_binding_compatible_v<B, typename C::binding_t>()) || ...);
+  return ([](){if constexpr (is_index_column<C> && !is_self_index_column<C>) { return (C::sorted && o2::soa::is_binding_compatible_v<B, typename C::binding_t>()); } else { return false; }}() || ...);
 }
 
 template <typename B, typename Z>
 consteval static bool relatedByIndex()
 {
-  return hasIndexTo<B>(typename Z::table_t::external_index_columns_t{});
+  return hasIndexTo<B>(typename Z::table_t::columns_t{});
 }
 
 template <typename B, typename Z>
 consteval static bool relatedBySortedIndex()
 {
-  return hasSortedIndexTo<B>(typename Z::table_t::external_index_columns_t{});
+  return hasSortedIndexTo<B>(typename Z::table_t::columns_t{});
 }
 } // namespace o2::soa
 
@@ -1716,16 +1727,13 @@ class Table
   using persistent_columns_t = decltype([]<typename... C>(framework::pack<C...>&&) -> framework::selected_pack<soa::is_persistent_column_t, C...> {}(columns_t{}));
   using column_types = decltype([]<typename... C>(framework::pack<C...>) -> framework::pack<typename C::type...> {}(persistent_columns_t{}));
 
-  using external_index_columns_t = decltype([]<typename... C>(framework::pack<C...>&&) -> framework::selected_pack<soa::is_external_index_t, C...> {}(columns_t{}));
-  using internal_index_columns_t = decltype([]<typename... C>(framework::pack<C...>&&) -> framework::selected_pack<soa::is_self_index_t, C...> {}(columns_t{}));
   template <typename IP>
   using base_iterator = decltype(base_iter<D, O, IP>(columns_t{}));
 
   template <typename IP, typename Parent, typename... T>
   struct TableIteratorBase : base_iterator<IP> {
     using columns_t = typename Parent::columns_t;
-    using external_index_columns_t = typename Parent::external_index_columns_t;
-    using bindings_pack_t = decltype([]<typename... C>(framework::pack<C...>) -> framework::pack<typename C::binding_t...> {}(external_index_columns_t{}));
+    using bindings_pack_t = typename base_iterator<IP>::bindings_pack_t;
     // static constexpr const std::array<TableRef, sizeof...(T)> originals{T::ref...};
     static constexpr auto originals = Parent::originals;
     using policy_t = IP;
@@ -1818,7 +1826,7 @@ class Table
       using decayed = std::decay_t<TI>;
       if constexpr (framework::has_type<decayed>(bindings_pack_t{})) { // index to another table
         constexpr auto idx = framework::has_type_at_v<decayed>(bindings_pack_t{});
-        return framework::pack_element_t<idx, external_index_columns_t>::getId();
+        return framework::pack_element_t<idx, columns_t>::getId();
       } else if constexpr (std::same_as<decayed, Parent>) { // self index
         return this->globalIndex();
       } else if constexpr (is_indexing_column<decayed>) { // soa::Index<>
@@ -2043,13 +2051,13 @@ class Table
 
   void bindInternalIndicesExplicit(o2::soa::Binding binding)
   {
-    doBindInternalIndicesExplicit(internal_index_columns_t{}, binding);
+    doBindInternalIndicesExplicit(columns_t{}, binding);
   }
 
   template <typename... Cs>
   void doBindInternalIndicesExplicit(framework::pack<Cs...>, o2::soa::Binding binding)
   {
-    (static_cast<Cs>(mBegin).setCurrentRaw(binding), ...);
+    ([this, &binding](){ if constexpr (is_self_index_column<Cs>) { static_cast<Cs>(mBegin).setCurrentRaw(binding); } }(), ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
@@ -2066,7 +2074,7 @@ class Table
   template <typename T>
   void copyIndexBindings(T& dest) const
   {
-    doCopyIndexBindings(external_index_columns_t{}, dest);
+    doCopyIndexBindings(columns_t{}, dest);
   }
 
   auto select(framework::expressions::Filter const& f) const
@@ -3343,7 +3351,6 @@ class FilteredBase : public T
   using T::originals;
   using columns_t = typename T::columns_t;
   using persistent_columns_t = typename T::persistent_columns_t;
-  using external_index_columns_t = typename T::external_index_columns_t;
 
   using iterator = T::template iterator_template_o<FilteredIndexPolicy, self_t>;
   using unfiltered_iterator = T::template iterator_template_o<DefaultIndexPolicy, self_t>;
@@ -3489,7 +3496,7 @@ class FilteredBase : public T
   template <typename T1>
   void copyIndexBindings(T1& dest) const
   {
-    doCopyIndexBindings(external_index_columns_t{}, dest);
+    doCopyIndexBindings(columns_t{}, dest);
   }
 
   template <typename T1>
diff --git a/Framework/Core/include/Framework/GroupedCombinations.h b/Framework/Core/include/Framework/GroupedCombinations.h
index b0a6c9e658a10..91ca1fefe3b7c 100644
--- a/Framework/Core/include/Framework/GroupedCombinations.h
+++ b/Framework/Core/include/Framework/GroupedCombinations.h
@@ -34,14 +34,27 @@ auto interleaveTuples(std::tuple<T1s...>& t1, std::tuple<T2s...>& t2)
   return interleaveTuplesImpl(t1, t2, std::index_sequence_for<T1s...>());
 }
 
+template <soa::is_index_column T, typename G>
+  requires(!soa::is_self_index_column<T>)
+auto isIndexTo()
+{
+  if constexpr (o2::soa::is_binding_compatible_v<G, typename T::binding_t>()) {
+    return std::true_type{};
+  } else {
+    return std::false_type{};
+  }
+}
+
+template <typename T, typename G>
+auto isIndexTo() ->std::false_type {}
+
 template <typename T, typename G>
-using is_index_to_g_t = typename std::conditional<o2::soa::is_binding_compatible_v<G, typename T::binding_t>(), std::true_type, std::false_type>::type;
+using is_index_to_g_t = decltype(isIndexTo<T, G>());
 
 template <typename G, typename A>
 expressions::BindingNode getMatchingIndexNode()
 {
-  using external_index_columns_pack = typename A::external_index_columns_t;
-  using selected_indices_t = selected_pack_multicondition<is_index_to_g_t, pack<G>, external_index_columns_pack>;
+  using selected_indices_t = selected_pack_multicondition<is_index_to_g_t, pack<G>, typename A::columns_t>;
   static_assert(pack_size(selected_indices_t{}) == 1, "No matching index column from associated to grouping");
   using index_column_t = pack_head_t<selected_indices_t>;
   return expressions::BindingNode{index_column_t::mLabel, o2::framework::TypeIdHelpers::uniqueId<typename index_column_t::column_t>(), expressions::selectArrowType<typename index_column_t::type>()};

From a2312ae4562e144e06d77620e301b85656a2238d Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 23 Jan 2025 13:11:01 +0100
Subject: [PATCH 03/20] fixup! DPL Analysis: remove unnecessary instances of
 selected_pack

---
 Framework/Core/include/Framework/ASoA.h       | 27 +++++++++++--------
 .../include/Framework/GroupedCombinations.h   |  4 ++-
 2 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 18f20cd177387..40b2bcfbb3129 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1035,11 +1035,15 @@ template <typename... C>
 concept has_index = (is_indexing_column<C> || ...);
 
 template <is_index_column C>
-  requires (!is_self_index_column<C>)
-auto getBinding() -> typename C::binding_t {}
+  requires(!is_self_index_column<C>)
+auto getBinding() -> typename C::binding_t
+{
+}
 
 template <typename C>
-auto getBinding() -> void {}
+auto getBinding() -> void
+{
+}
 
 template <typename D, typename O, typename IP, typename... C>
 struct TableIterator : IP, C... {
@@ -1143,7 +1147,7 @@ struct TableIterator : IP, C... {
   template <typename... CL, typename TA>
   void doSetCurrentIndex(framework::pack<CL...>, TA* current)
   {
-    ([&current, this](){ if constexpr (is_index_column<CL> && !is_self_index_column<CL>) {CL::setCurrent(current);} }(), ...);
+    ([&current, this]() { if constexpr (is_index_column<CL> && !is_self_index_column<CL>) {CL::setCurrent(current);} }(), ...);
   }
 
   template <typename CL>
@@ -1156,11 +1160,12 @@ struct TableIterator : IP, C... {
   auto getIndexBindingsImpl(framework::pack<Cs...>) const
   {
     std::vector<o2::soa::Binding> result;
-    ([this, &result](){
+    ([this, &result]() {
       if constexpr (is_index_column<Cs> && !is_self_index_column<Cs>) {
         result.emplace_back(static_cast<Cs const&>(*this).getCurrentRaw());
       }
-    }(), ...);
+    }(),
+     ...);
     return result;
   }
 
@@ -1178,7 +1183,7 @@ struct TableIterator : IP, C... {
   template <typename... Cs>
   void doSetCurrentIndexRaw(framework::pack<Cs...> p, std::vector<o2::soa::Binding>&& ptrs)
   {
-    ([&ptrs, p, this](){ if constexpr (is_index_column<Cs> && !is_self_index_column<Cs>) { Cs::setCurrentRaw(ptrs[framework::has_type_at_v<Cs>(p)]); } }(), ...);
+    ([&ptrs, p, this]() { if constexpr (is_index_column<Cs> && !is_self_index_column<Cs>) { Cs::setCurrentRaw(ptrs[framework::has_type_at_v<Cs>(p)]); } }(), ...);
   }
 
   template <typename... Cs, typename I>
@@ -1186,7 +1191,7 @@ struct TableIterator : IP, C... {
   {
     o2::soa::Binding b;
     b.bind(ptr);
-    ([&ptr, &b, this](){ if constexpr (is_self_index_column<Cs>) { Cs::setCurrentRaw(b); } }(), ...);
+    ([&ptr, &b, this]() { if constexpr (is_self_index_column<Cs>) { Cs::setCurrentRaw(b); } }(), ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
@@ -1381,13 +1386,13 @@ static constexpr std::string getLabelFromTypeForKey(std::string const& key)
 template <typename B, typename... C>
 consteval static bool hasIndexTo(framework::pack<C...>&&)
 {
-  return ([](){ if constexpr (is_index_column<C> && !is_self_index_column<C>) { return o2::soa::is_binding_compatible_v<B, typename C::binding_t>(); } else { return false; } }() || ...);
+  return ([]() { if constexpr (is_index_column<C> && !is_self_index_column<C>) { return o2::soa::is_binding_compatible_v<B, typename C::binding_t>(); } else { return false; } }() || ...);
 }
 
 template <typename B, typename... C>
 consteval static bool hasSortedIndexTo(framework::pack<C...>&&)
 {
-  return ([](){if constexpr (is_index_column<C> && !is_self_index_column<C>) { return (C::sorted && o2::soa::is_binding_compatible_v<B, typename C::binding_t>()); } else { return false; }}() || ...);
+  return ([]() {if constexpr (is_index_column<C> && !is_self_index_column<C>) { return (C::sorted && o2::soa::is_binding_compatible_v<B, typename C::binding_t>()); } else { return false; } }() || ...);
 }
 
 template <typename B, typename Z>
@@ -2057,7 +2062,7 @@ class Table
   template <typename... Cs>
   void doBindInternalIndicesExplicit(framework::pack<Cs...>, o2::soa::Binding binding)
   {
-    ([this, &binding](){ if constexpr (is_self_index_column<Cs>) { static_cast<Cs>(mBegin).setCurrentRaw(binding); } }(), ...);
+    ([this, &binding]() { if constexpr (is_self_index_column<Cs>) { static_cast<Cs>(mBegin).setCurrentRaw(binding); } }(), ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
diff --git a/Framework/Core/include/Framework/GroupedCombinations.h b/Framework/Core/include/Framework/GroupedCombinations.h
index 91ca1fefe3b7c..abf5a36381508 100644
--- a/Framework/Core/include/Framework/GroupedCombinations.h
+++ b/Framework/Core/include/Framework/GroupedCombinations.h
@@ -46,7 +46,9 @@ auto isIndexTo()
 }
 
 template <typename T, typename G>
-auto isIndexTo() ->std::false_type {}
+auto isIndexTo() -> std::false_type
+{
+}
 
 template <typename T, typename G>
 using is_index_to_g_t = decltype(isIndexTo<T, G>());

From 16ea3a843452ef7a009f1d46f08aa95b58cab56f Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 23 Jan 2025 13:35:39 +0100
Subject: [PATCH 04/20] fixup! DPL Analysis: remove unnecessary instances of
 selected_pack

---
 Framework/Core/include/Framework/GroupedCombinations.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/GroupedCombinations.h b/Framework/Core/include/Framework/GroupedCombinations.h
index abf5a36381508..7bed8519030fd 100644
--- a/Framework/Core/include/Framework/GroupedCombinations.h
+++ b/Framework/Core/include/Framework/GroupedCombinations.h
@@ -46,8 +46,9 @@ auto isIndexTo()
 }
 
 template <typename T, typename G>
-auto isIndexTo() -> std::false_type
+auto isIndexTo()
 {
+  return std::false_type{};
 }
 
 template <typename T, typename G>

From 9f7e13eecdf8cc40d7420493e41681d20d1d7a69 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 23 Jan 2025 13:36:14 +0100
Subject: [PATCH 05/20] fixup! DPL Analysis: remove unnecessary instances of
 selected_pack

---
 Framework/Core/include/Framework/GroupedCombinations.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/GroupedCombinations.h b/Framework/Core/include/Framework/GroupedCombinations.h
index 7bed8519030fd..3f48086fe0380 100644
--- a/Framework/Core/include/Framework/GroupedCombinations.h
+++ b/Framework/Core/include/Framework/GroupedCombinations.h
@@ -36,7 +36,7 @@ auto interleaveTuples(std::tuple<T1s...>& t1, std::tuple<T2s...>& t2)
 
 template <soa::is_index_column T, typename G>
   requires(!soa::is_self_index_column<T>)
-auto isIndexTo()
+constexpr auto isIndexTo()
 {
   if constexpr (o2::soa::is_binding_compatible_v<G, typename T::binding_t>()) {
     return std::true_type{};
@@ -46,7 +46,7 @@ auto isIndexTo()
 }
 
 template <typename T, typename G>
-auto isIndexTo()
+constexpr auto isIndexTo()
 {
   return std::false_type{};
 }

From b472ec7784f9915e62eb8129b73a535d430eb6b2 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 23 Jan 2025 14:24:11 +0100
Subject: [PATCH 06/20] fixup! DPL Analysis: remove unnecessary instances of
 selected_pack

---
 Framework/Core/include/Framework/ASoA.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 40b2bcfbb3129..3ca9f46f66232 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1036,12 +1036,12 @@ concept has_index = (is_indexing_column<C> || ...);
 
 template <is_index_column C>
   requires(!is_self_index_column<C>)
-auto getBinding() -> typename C::binding_t
+constexpr auto getBinding() -> typename C::binding_t
 {
 }
 
 template <typename C>
-auto getBinding() -> void
+constexpr auto getBinding() -> void
 {
 }
 

From 84cee9a49111941fb26cc647e6d4cbad85174c18 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 23 Jan 2025 14:26:12 +0100
Subject: [PATCH 07/20] fixup! DPL Analysis: remove unnecessary instances of
 selected_pack

---
 Framework/Core/include/Framework/ASoA.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 3ca9f46f66232..6be2657a90aca 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1036,12 +1036,12 @@ concept has_index = (is_indexing_column<C> || ...);
 
 template <is_index_column C>
   requires(!is_self_index_column<C>)
-constexpr auto getBinding() -> typename C::binding_t
+consteval auto getBinding() -> typename C::binding_t
 {
 }
 
 template <typename C>
-constexpr auto getBinding() -> void
+consteval auto getBinding() -> void
 {
 }
 

From 4d3fa45a969d1763a627f93c62ea7c209455bb90 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 23 Jan 2025 14:30:07 +0100
Subject: [PATCH 08/20] fixup! DPL Analysis: remove unnecessary instances of
 selected_pack

---
 Framework/Core/include/Framework/GroupedCombinations.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/GroupedCombinations.h b/Framework/Core/include/Framework/GroupedCombinations.h
index 3f48086fe0380..2f8a5d3320f48 100644
--- a/Framework/Core/include/Framework/GroupedCombinations.h
+++ b/Framework/Core/include/Framework/GroupedCombinations.h
@@ -36,7 +36,7 @@ auto interleaveTuples(std::tuple<T1s...>& t1, std::tuple<T2s...>& t2)
 
 template <soa::is_index_column T, typename G>
   requires(!soa::is_self_index_column<T>)
-constexpr auto isIndexTo()
+consteval auto isIndexTo()
 {
   if constexpr (o2::soa::is_binding_compatible_v<G, typename T::binding_t>()) {
     return std::true_type{};
@@ -46,7 +46,7 @@ constexpr auto isIndexTo()
 }
 
 template <typename T, typename G>
-constexpr auto isIndexTo()
+consteval auto isIndexTo()
 {
   return std::false_type{};
 }

From c67d408d885a9d06409c8de7ccef484e3e6779bd Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 24 Jan 2025 11:11:01 +0100
Subject: [PATCH 09/20] use requirements instead of if-constexpr

---
 Framework/Core/include/Framework/ASoA.h | 42 ++++++++++++++++++-------
 1 file changed, 30 insertions(+), 12 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 6be2657a90aca..cbcc6a97b91f1 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1147,7 +1147,10 @@ struct TableIterator : IP, C... {
   template <typename... CL, typename TA>
   void doSetCurrentIndex(framework::pack<CL...>, TA* current)
   {
-    ([&current, this]() { if constexpr (is_index_column<CL> && !is_self_index_column<CL>) {CL::setCurrent(current);} }(), ...);
+    (framework::overloaded{
+       [&current, this]<is_index_column CI> requires(!is_self_index_column<CI>) () { CI::setCurrent(current); },
+       []<typename CI>(){}
+       }.template operator()<CL>(), ...);
   }
 
   template <typename CL>
@@ -1160,12 +1163,12 @@ struct TableIterator : IP, C... {
   auto getIndexBindingsImpl(framework::pack<Cs...>) const
   {
     std::vector<o2::soa::Binding> result;
-    ([this, &result]() {
-      if constexpr (is_index_column<Cs> && !is_self_index_column<Cs>) {
-        result.emplace_back(static_cast<Cs const&>(*this).getCurrentRaw());
-      }
-    }(),
-     ...);
+    (framework::overloaded{
+       [this, &result]<is_index_column CI> requires(!is_self_index_column<CI>) () mutable {
+           result.emplace_back(CI::getCurrentRaw());
+       },
+       []<typename CI>(){}
+      }.template operator()<Cs>(), ...);
     return result;
   }
 
@@ -1183,7 +1186,10 @@ struct TableIterator : IP, C... {
   template <typename... Cs>
   void doSetCurrentIndexRaw(framework::pack<Cs...> p, std::vector<o2::soa::Binding>&& ptrs)
   {
-    ([&ptrs, p, this]() { if constexpr (is_index_column<Cs> && !is_self_index_column<Cs>) { Cs::setCurrentRaw(ptrs[framework::has_type_at_v<Cs>(p)]); } }(), ...);
+    (framework::overloaded{
+      [&ptrs, p, this]<is_self_index_column CI> requires(!is_self_index_column<CI>) () { CI::setCurrentRaw(ptrs[framework::has_type_at_v<CI>(p)]); },
+      []<typename CI>(){}
+    }.template operator()<Cs>(), ...);
   }
 
   template <typename... Cs, typename I>
@@ -1191,7 +1197,10 @@ struct TableIterator : IP, C... {
   {
     o2::soa::Binding b;
     b.bind(ptr);
-    ([&ptr, &b, this]() { if constexpr (is_self_index_column<Cs>) { Cs::setCurrentRaw(b); } }(), ...);
+    (framework::overloaded{
+      [&ptr, &b, this]<is_self_index_column CI>() { CI::setCurrentRaw(b); },
+      []<typename CI>(){}
+     }.template operator()<Cs>(), ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
@@ -1386,13 +1395,19 @@ static constexpr std::string getLabelFromTypeForKey(std::string const& key)
 template <typename B, typename... C>
 consteval static bool hasIndexTo(framework::pack<C...>&&)
 {
-  return ([]() { if constexpr (is_index_column<C> && !is_self_index_column<C>) { return o2::soa::is_binding_compatible_v<B, typename C::binding_t>(); } else { return false; } }() || ...);
+  return (framework::overloaded{
+            []<is_index_column CI> requires(!is_self_index_column<CI>) () { return o2::soa::is_binding_compatible_v<B, typename CI::binding_t>(); },
+            []<typename CI>(){ return false; }
+          }.template operator()<C>() || ...);
 }
 
 template <typename B, typename... C>
 consteval static bool hasSortedIndexTo(framework::pack<C...>&&)
 {
-  return ([]() {if constexpr (is_index_column<C> && !is_self_index_column<C>) { return (C::sorted && o2::soa::is_binding_compatible_v<B, typename C::binding_t>()); } else { return false; } }() || ...);
+  return (framework::overloaded{
+            []<is_index_column CI> requires(!is_self_index_column<CI>) () {return (CI::sorted && o2::soa::is_binding_compatible_v<B, typename CI::binding_t>()); },
+            []<typename CI>(){}
+          }.template operator()<C>() || ...);
 }
 
 template <typename B, typename Z>
@@ -2062,7 +2077,10 @@ class Table
   template <typename... Cs>
   void doBindInternalIndicesExplicit(framework::pack<Cs...>, o2::soa::Binding binding)
   {
-    ([this, &binding]() { if constexpr (is_self_index_column<Cs>) { static_cast<Cs>(mBegin).setCurrentRaw(binding); } }(), ...);
+    (framework::overloaded{
+      [this, &binding]<is_self_index_column CI>() { static_cast<CI>(mBegin).setCurrentRaw(binding); },
+      []<typename CI>(){}
+     }.template operator()<Cs>(), ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)

From 8234bde5ed4c7c8fae82548c276ca1e11614a847 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 24 Jan 2025 11:13:17 +0100
Subject: [PATCH 10/20] fixup! use requirements instead of if-constexpr

---
 Framework/Core/include/Framework/ASoA.h | 63 ++++++++++++++++---------
 1 file changed, 40 insertions(+), 23 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index cbcc6a97b91f1..b6184921c96d9 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1148,9 +1148,12 @@ struct TableIterator : IP, C... {
   void doSetCurrentIndex(framework::pack<CL...>, TA* current)
   {
     (framework::overloaded{
-       [&current, this]<is_index_column CI> requires(!is_self_index_column<CI>) () { CI::setCurrent(current); },
-       []<typename CI>(){}
-       }.template operator()<CL>(), ...);
+      [&current, this]<is_index_column CI>
+        requires(!is_self_index_column<CI>)
+      () { CI::setCurrent(current); },
+      []<typename CI>() {}}
+        .template operator()<CL>(),
+      ...);
   }
 
   template <typename CL>
@@ -1164,11 +1167,14 @@ struct TableIterator : IP, C... {
   {
     std::vector<o2::soa::Binding> result;
     (framework::overloaded{
-       [this, &result]<is_index_column CI> requires(!is_self_index_column<CI>) () mutable {
-           result.emplace_back(CI::getCurrentRaw());
-       },
-       []<typename CI>(){}
-      }.template operator()<Cs>(), ...);
+      [this, &result]<is_index_column CI>
+        requires(!is_self_index_column<CI>)
+      () mutable {
+        result.emplace_back(CI::getCurrentRaw());
+      },
+      []<typename CI>() {}}
+        .template operator()<Cs>(),
+      ...);
     return result;
   }
 
@@ -1187,9 +1193,12 @@ struct TableIterator : IP, C... {
   void doSetCurrentIndexRaw(framework::pack<Cs...> p, std::vector<o2::soa::Binding>&& ptrs)
   {
     (framework::overloaded{
-      [&ptrs, p, this]<is_self_index_column CI> requires(!is_self_index_column<CI>) () { CI::setCurrentRaw(ptrs[framework::has_type_at_v<CI>(p)]); },
-      []<typename CI>(){}
-    }.template operator()<Cs>(), ...);
+      [&ptrs, p, this]<is_self_index_column CI>
+        requires(!is_self_index_column<CI>)
+      () { CI::setCurrentRaw(ptrs[framework::has_type_at_v<CI>(p)]); },
+      []<typename CI>() {}}
+        .template operator()<Cs>(),
+      ...);
   }
 
   template <typename... Cs, typename I>
@@ -1198,9 +1207,10 @@ struct TableIterator : IP, C... {
     o2::soa::Binding b;
     b.bind(ptr);
     (framework::overloaded{
-      [&ptr, &b, this]<is_self_index_column CI>() { CI::setCurrentRaw(b); },
-      []<typename CI>(){}
-     }.template operator()<Cs>(), ...);
+       [&ptr, &b, this]<is_self_index_column CI>() { CI::setCurrentRaw(b); },
+       []<typename CI>() {}}
+       .template operator()<Cs>(),
+     ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
@@ -1396,18 +1406,24 @@ template <typename B, typename... C>
 consteval static bool hasIndexTo(framework::pack<C...>&&)
 {
   return (framework::overloaded{
-            []<is_index_column CI> requires(!is_self_index_column<CI>) () { return o2::soa::is_binding_compatible_v<B, typename CI::binding_t>(); },
-            []<typename CI>(){ return false; }
-          }.template operator()<C>() || ...);
+    []<is_index_column CI>
+      requires(!is_self_index_column<CI>)
+    () { return o2::soa::is_binding_compatible_v<B, typename CI::binding_t>(); },
+    []<typename CI>() { return false; }}
+      .template operator()<C>() ||
+    ...);
 }
 
 template <typename B, typename... C>
 consteval static bool hasSortedIndexTo(framework::pack<C...>&&)
 {
   return (framework::overloaded{
-            []<is_index_column CI> requires(!is_self_index_column<CI>) () {return (CI::sorted && o2::soa::is_binding_compatible_v<B, typename CI::binding_t>()); },
-            []<typename CI>(){}
-          }.template operator()<C>() || ...);
+    []<is_index_column CI>
+      requires(!is_self_index_column<CI>)
+    () { return (CI::sorted && o2::soa::is_binding_compatible_v<B, typename CI::binding_t>()); },
+    []<typename CI>() {}}
+      .template operator()<C>() ||
+    ...);
 }
 
 template <typename B, typename Z>
@@ -2078,9 +2094,10 @@ class Table
   void doBindInternalIndicesExplicit(framework::pack<Cs...>, o2::soa::Binding binding)
   {
     (framework::overloaded{
-      [this, &binding]<is_self_index_column CI>() { static_cast<CI>(mBegin).setCurrentRaw(binding); },
-      []<typename CI>(){}
-     }.template operator()<Cs>(), ...);
+       [this, &binding]<is_self_index_column CI>() { static_cast<CI>(mBegin).setCurrentRaw(binding); },
+       []<typename CI>() {}}
+       .template operator()<Cs>(),
+     ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)

From f09930a1fd3f7850a3cd9654c1e1779817669eaf Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Wed, 29 Jan 2025 14:14:53 +0100
Subject: [PATCH 11/20] avoid overloaded{}; fix index binding ignored in
 certain cases

---
 Framework/Core/include/Framework/ASoA.h       | 179 ++++++++++++------
 .../include/Framework/GroupedCombinations.h   |  20 +-
 2 files changed, 135 insertions(+), 64 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index b6184921c96d9..dc98be9155e04 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1147,13 +1147,7 @@ struct TableIterator : IP, C... {
   template <typename... CL, typename TA>
   void doSetCurrentIndex(framework::pack<CL...>, TA* current)
   {
-    (framework::overloaded{
-      [&current, this]<is_index_column CI>
-        requires(!is_self_index_column<CI>)
-      () { CI::setCurrent(current); },
-      []<typename CI>() {}}
-        .template operator()<CL>(),
-      ...);
+    (doSetCurrentIndexImpl<CL>(current), ...);
   }
 
   template <typename CL>
@@ -1166,15 +1160,7 @@ struct TableIterator : IP, C... {
   auto getIndexBindingsImpl(framework::pack<Cs...>) const
   {
     std::vector<o2::soa::Binding> result;
-    (framework::overloaded{
-      [this, &result]<is_index_column CI>
-        requires(!is_self_index_column<CI>)
-      () mutable {
-        result.emplace_back(CI::getCurrentRaw());
-      },
-      []<typename CI>() {}}
-        .template operator()<Cs>(),
-      ...);
+    (doGetIndexBindingImpl<Cs>(result), ...);
     return result;
   }
 
@@ -1190,15 +1176,9 @@ struct TableIterator : IP, C... {
   }
 
   template <typename... Cs>
-  void doSetCurrentIndexRaw(framework::pack<Cs...> p, std::vector<o2::soa::Binding>&& ptrs)
+  void doSetCurrentIndexRaw(framework::pack<Cs...> p, std::vector<o2::soa::Binding>&& bindings)
   {
-    (framework::overloaded{
-      [&ptrs, p, this]<is_self_index_column CI>
-        requires(!is_self_index_column<CI>)
-      () { CI::setCurrentRaw(ptrs[framework::has_type_at_v<CI>(p)]); },
-      []<typename CI>() {}}
-        .template operator()<Cs>(),
-      ...);
+    (doSetCurrentIndexRawImpl<Cs>(bindings[framework::has_type_at_v<Cs>(p)]), ...);
   }
 
   template <typename... Cs, typename I>
@@ -1206,16 +1186,12 @@ struct TableIterator : IP, C... {
   {
     o2::soa::Binding b;
     b.bind(ptr);
-    (framework::overloaded{
-       [&ptr, &b, this]<is_self_index_column CI>() { CI::setCurrentRaw(b); },
-       []<typename CI>() {}}
-       .template operator()<Cs>(),
-     ...);
+    (doSetCurrentInternalImpl<Cs>(b), ...);
   }
 
-  void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
+  void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& bindings)
   {
-    doSetCurrentIndexRaw(all_columns{}, std::forward<std::vector<o2::soa::Binding>>(ptrs));
+    doSetCurrentIndexRaw(all_columns{}, std::forward<std::vector<o2::soa::Binding>>(bindings));
   }
 
   template <typename I>
@@ -1225,6 +1201,78 @@ struct TableIterator : IP, C... {
   }
 
  private:
+  /// Overloaded helpers for index manipulations
+  template <soa::is_index_column CL, typename TA>
+    requires(!soa::is_self_index_column<CL>)
+  void doSetCurrentIndexImpl(TA* current)
+  {
+    CL::setCurrent(current);
+  }
+
+  template <soa::is_column CL, typename TA>
+    requires(!soa::is_index_column<CL>)
+  void doSetCurrentIndexImpl(TA*)
+  {
+  }
+
+  template <soa::is_index_column CL>
+    requires(!soa::is_self_index_column<CL>)
+  auto doGetIndexBindingImpl(std::vector<o2::soa::Binding>& bindings) const
+  {
+    bindings.emplace_back(CL::getCurrentRaw());
+  }
+
+  template <soa::is_column CL>
+    requires(!soa::is_index_column<CL>)
+  auto doGetIndexBindingImpl(std::vector<o2::soa::Binding>& bindings) const
+  {
+    bindings.emplace_back();
+  }
+
+  template <soa::is_index_column CL>
+    requires(!soa::is_self_index_column<CL>)
+  void doSetCurrentIndexRawImpl(o2::soa::Binding const& b)
+  {
+    CL::setCurrentRaw(b);
+  }
+
+  template <soa::is_column CL>
+    requires(!soa::is_index_column<CL>)
+  void doSetCurrentIndexRawImpl(o2::soa::Binding const&)
+  {
+  }
+
+  template <soa::is_self_index_column CL>
+  void doSetCurrentInternalImpl(o2::soa::Binding const& b)
+  {
+    CL::setCurrentRaw(b);
+  }
+
+  template <soa::is_column CL>
+    requires(!soa::is_self_index_column<CL>)
+  void doSetCurrentInternalImpl(o2::soa::Binding const&)
+  {
+  }
+
+  ///Overloaded helpers for column binding
+  template <soa::is_persistent_column CL>
+  void doBind()
+  {
+    CL::mColumnIterator.mCurrentPos = &this->mRowIndex;
+  }
+
+  template <soa::is_dynamic_column CL>
+  void doBind()
+  {
+    bindDynamicColumn<CL>(typename CL::bindings_t{});
+  }
+
+  template <soa::is_column CL>
+    requires(!soa::is_persistent_column<CL> && !soa::is_dynamic_column<CL>)
+  void doBind()
+  {
+  }
+
   /// Helper to move at the end of columns which actually have an iterator.
   template <typename... PC>
   void doMoveToEnd(framework::pack<PC...>)
@@ -1237,12 +1285,7 @@ struct TableIterator : IP, C... {
   void bind()
   {
     using namespace o2::soa;
-    auto f = framework::overloaded{
-      [this]<soa::is_persistent_column T>(T*) -> void { T::mColumnIterator.mCurrentPos = &this->mRowIndex; },
-      [this]<soa::is_dynamic_column T>(T*) -> void { bindDynamicColumn<T>(typename T::bindings_t{}); },
-      [this]<typename T>(T*) -> void {},
-    };
-    (f(static_cast<C*>(nullptr)), ...);
+    (doBind<C>(), ...);
     if constexpr (has_index<C...>) {
       this->setIndices(this->getIndices());
       this->setOffsets(this->getOffsets());
@@ -1402,28 +1445,44 @@ static constexpr std::string getLabelFromTypeForKey(std::string const& key)
   O2_BUILTIN_UNREACHABLE();
 }
 
+template <soa::is_index_column CL, typename B>
+  requires(!soa::is_self_index_column<CL>)
+consteval static bool hasIndexToImpl()
+{
+  return o2::soa::is_binding_compatible_v<B, typename CL::binding_t>();
+}
+
+template <soa::is_column CL, typename B>
+  requires(!soa::is_index_column<CL>)
+consteval static bool hasIndexToImpl()
+{
+  return false;
+}
+
 template <typename B, typename... C>
 consteval static bool hasIndexTo(framework::pack<C...>&&)
 {
-  return (framework::overloaded{
-    []<is_index_column CI>
-      requires(!is_self_index_column<CI>)
-    () { return o2::soa::is_binding_compatible_v<B, typename CI::binding_t>(); },
-    []<typename CI>() { return false; }}
-      .template operator()<C>() ||
-    ...);
+  return (hasIndexToImpl<C, B>() || ...);
+}
+
+template <soa::is_index_column CL, typename B>
+  requires(!soa::is_self_index_column<CL>)
+consteval static bool hasSortedIndexToImpl()
+{
+  return CL::sorted && o2::soa::is_binding_compatible_v<B, typename CL::binding_t>();
+}
+
+template <soa::is_column CL, typename B>
+  requires(!soa::is_index_column<CL>)
+consteval static bool hasSortedIndexToImpl()
+{
+  return false;
 }
 
 template <typename B, typename... C>
 consteval static bool hasSortedIndexTo(framework::pack<C...>&&)
 {
-  return (framework::overloaded{
-    []<is_index_column CI>
-      requires(!is_self_index_column<CI>)
-    () { return (CI::sorted && o2::soa::is_binding_compatible_v<B, typename CI::binding_t>()); },
-    []<typename CI>() {}}
-      .template operator()<C>() ||
-    ...);
+  return (hasSortedIndexToImpl<C, B>() || ...);
 }
 
 template <typename B, typename Z>
@@ -2090,14 +2149,22 @@ class Table
     doBindInternalIndicesExplicit(columns_t{}, binding);
   }
 
+  template <soa::is_self_index_column CL>
+  void doBindInternalIndicesExplicitImpl(o2::soa::Binding binding)
+  {
+    static_cast<CL>(mBegin).setCurrentRaw(binding);
+  }
+
+  template <soa::is_column CL>
+    requires(!soa::is_self_index_column<CL>)
+  void doBindInternalIndicesExplicitImpl(o2::soa::Binding)
+  {
+  }
+
   template <typename... Cs>
   void doBindInternalIndicesExplicit(framework::pack<Cs...>, o2::soa::Binding binding)
   {
-    (framework::overloaded{
-       [this, &binding]<is_self_index_column CI>() { static_cast<CI>(mBegin).setCurrentRaw(binding); },
-       []<typename CI>() {}}
-       .template operator()<Cs>(),
-     ...);
+    (doBindInternalIndicesExplicitImpl<Cs>(binding), ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
diff --git a/Framework/Core/include/Framework/GroupedCombinations.h b/Framework/Core/include/Framework/GroupedCombinations.h
index 2f8a5d3320f48..6ca7bbef1cbfa 100644
--- a/Framework/Core/include/Framework/GroupedCombinations.h
+++ b/Framework/Core/include/Framework/GroupedCombinations.h
@@ -34,18 +34,22 @@ auto interleaveTuples(std::tuple<T1s...>& t1, std::tuple<T2s...>& t2)
   return interleaveTuplesImpl(t1, t2, std::index_sequence_for<T1s...>());
 }
 
-template <soa::is_index_column T, typename G>
-  requires(!soa::is_self_index_column<T>)
+template <soa::is_index_column T, soa::is_table G>
+  requires(!soa::is_self_index_column<T> && o2::soa::is_binding_compatible_v<std::decay_t<G>, typename std::decay_t<T>::binding_t>())
 consteval auto isIndexTo()
 {
-  if constexpr (o2::soa::is_binding_compatible_v<G, typename T::binding_t>()) {
-    return std::true_type{};
-  } else {
-    return std::false_type{};
-  }
+  return std::true_type{};
 }
 
-template <typename T, typename G>
+template <soa::is_index_column T, soa::is_table G>
+  requires(!soa::is_self_index_column<T> && !o2::soa::is_binding_compatible_v<std::decay_t<G>, typename std::decay_t<T>::binding_t>())
+consteval auto isIndexTo()
+{
+  return std::false_type{};
+}
+
+template <soa::is_column T, soa::is_table G>
+  requires(!soa::is_index_column<T>)
 consteval auto isIndexTo()
 {
   return std::false_type{};

From be7018abf5c18f505250cc7733783b41eb960fb4 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Wed, 29 Jan 2025 14:23:20 +0100
Subject: [PATCH 12/20] format

---
 Framework/Core/include/Framework/ASoA.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index dc98be9155e04..b3913a0e24d73 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1254,7 +1254,7 @@ struct TableIterator : IP, C... {
   {
   }
 
-  ///Overloaded helpers for column binding
+  /// Overloaded helpers for column binding
   template <soa::is_persistent_column CL>
   void doBind()
   {

From 4e3732b79a26b707db619164e34a1802aab376bf Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 28 Mar 2025 12:36:27 +0100
Subject: [PATCH 13/20] get rid of bindings_pack_t

---
 Framework/Core/include/Framework/ASoA.h | 37 ++++++++++++++-----------
 1 file changed, 21 insertions(+), 16 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index b3913a0e24d73..4c37730f06659 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1045,6 +1045,12 @@ consteval auto getBinding() -> void
 {
 }
 
+template <typename T, typename... Cs>
+consteval auto inBindings(framework::pack<Cs...>)
+{
+  return framework::has_type_at_v<T>(framework::pack<decltype(getBinding<Cs>())...>{});
+}
+
 template <typename D, typename O, typename IP, typename... C>
 struct TableIterator : IP, C... {
  public:
@@ -1052,9 +1058,6 @@ struct TableIterator : IP, C... {
   using policy_t = IP;
   using all_columns = framework::pack<C...>;
   using persistent_columns_t = framework::selected_pack<soa::is_persistent_column_t, C...>;
-  using bindings_pack_t = decltype([]<typename... Cs>(framework::pack<Cs...>) {
-    return framework::pack<decltype(getBinding<Cs>())...>{};
-  }(all_columns{}));
 
   TableIterator(arrow::ChunkedArray* columnData[sizeof...(C)], IP&& policy)
     : IP{policy},
@@ -1828,8 +1831,6 @@ class Table
   template <typename IP, typename Parent, typename... T>
   struct TableIteratorBase : base_iterator<IP> {
     using columns_t = typename Parent::columns_t;
-    using bindings_pack_t = typename base_iterator<IP>::bindings_pack_t;
-    // static constexpr const std::array<TableRef, sizeof...(T)> originals{T::ref...};
     static constexpr auto originals = Parent::originals;
     using policy_t = IP;
     using parent_t = Parent;
@@ -1918,17 +1919,21 @@ class Table
     template <typename TI>
     auto getId() const
     {
-      using decayed = std::decay_t<TI>;
-      if constexpr (framework::has_type<decayed>(bindings_pack_t{})) { // index to another table
-        constexpr auto idx = framework::has_type_at_v<decayed>(bindings_pack_t{});
-        return framework::pack_element_t<idx, columns_t>::getId();
-      } else if constexpr (std::same_as<decayed, Parent>) { // self index
-        return this->globalIndex();
-      } else if constexpr (is_indexing_column<decayed>) { // soa::Index<>
-        return this->globalIndex();
-      } else {
-        return static_cast<int32_t>(-1);
-      }
+      return static_cast<int32_t>(-1);
+    }
+
+    template <typename TI>
+      requires(std::same_as<std::decay_t<TI>, Parent> || is_indexing_column<std::decay_t<TI>>)
+    auto getId() const
+    {
+      return this->globalIndex();
+    }
+
+    template <typename TI>
+      requires(inBindings<std::decay_t<TI>>(typename Parent::all_columns{}) < framework::pack_size(typename Parent::all_columns{}))
+    auto getId() const
+    {
+      return inBindings<std::decay_t<TI>>(typename Parent::all_columns{});
     }
 
     template <soa::is_dynamic_column CD, typename... CDArgs>

From 5f7c49242593f66347d1bb26c23d22cecc711143 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 31 Mar 2025 10:54:16 +0200
Subject: [PATCH 14/20] do not use all_columns pack where the template
 arguments are available

---
 Framework/Core/include/Framework/ASoA.h | 44 +++++++------------------
 1 file changed, 11 insertions(+), 33 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 4c37730f06659..c83a7f666bee6 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1061,7 +1061,7 @@ struct TableIterator : IP, C... {
 
   TableIterator(arrow::ChunkedArray* columnData[sizeof...(C)], IP&& policy)
     : IP{policy},
-      C(columnData[framework::has_type_at_v<C>(all_columns{})])...
+      C(columnData[framework::has_type_at_v<C>(framework::pack<C...>{})])...
   {
     bind();
   }
@@ -1069,7 +1069,7 @@ struct TableIterator : IP, C... {
   TableIterator(arrow::ChunkedArray* columnData[sizeof...(C)], IP&& policy)
     requires(has_index<C...>)
     : IP{policy},
-      C(columnData[framework::has_type_at_v<C>(all_columns{})])...
+      C(columnData[framework::has_type_at_v<C>(framework::pack<C...>{})])...
   {
     bind();
     // In case we have an index column might need to constrain the actual
@@ -1147,60 +1147,38 @@ struct TableIterator : IP, C... {
     return *this;
   }
 
-  template <typename... CL, typename TA>
-  void doSetCurrentIndex(framework::pack<CL...>, TA* current)
-  {
-    (doSetCurrentIndexImpl<CL>(current), ...);
-  }
-
   template <typename CL>
   auto getCurrent() const
   {
     return CL::getCurrentRaw();
   }
 
-  template <typename... Cs>
-  auto getIndexBindingsImpl(framework::pack<Cs...>) const
+  auto getIndexBindings() const
   {
     std::vector<o2::soa::Binding> result;
-    (doGetIndexBindingImpl<Cs>(result), ...);
+    (doGetIndexBindingImpl<C>(result), ...);
     return result;
   }
 
-  auto getIndexBindings() const
-  {
-    return getIndexBindingsImpl(all_columns{});
-  }
-
   template <typename... TA>
   void bindExternalIndices(TA*... current)
   {
-    (doSetCurrentIndex(all_columns{}, current), ...);
-  }
-
-  template <typename... Cs>
-  void doSetCurrentIndexRaw(framework::pack<Cs...> p, std::vector<o2::soa::Binding>&& bindings)
-  {
-    (doSetCurrentIndexRawImpl<Cs>(bindings[framework::has_type_at_v<Cs>(p)]), ...);
-  }
-
-  template <typename... Cs, typename I>
-  void doSetCurrentInternal(framework::pack<Cs...>, I const* ptr)
-  {
-    o2::soa::Binding b;
-    b.bind(ptr);
-    (doSetCurrentInternalImpl<Cs>(b), ...);
+    ([this]<typename... Cs, typename TT>(framework::pack<Cs...>, TT* t){
+      (doSetCurrentIndexImpl<Cs>(t), ...);
+    }(framework::pack<C...>{}, current), ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& bindings)
   {
-    doSetCurrentIndexRaw(all_columns{}, std::forward<std::vector<o2::soa::Binding>>(bindings));
+    (doSetCurrentIndexRawImpl<C>(bindings[framework::has_type_at_v<C>(framework::pack<C...>{})]), ...);
   }
 
   template <typename I>
   void bindInternalIndices(I const* table)
   {
-    doSetCurrentInternal(all_columns{}, table);
+    o2::soa::Binding b;
+    b.bind(table);
+    (doSetCurrentInternalImpl<C>(b), ...);
   }
 
  private:

From 9e77fe49a78954d164cb76e8748dc4da8615649b Mon Sep 17 00:00:00 2001
From: ALICE Action Bot <alibuild@cern.ch>
Date: Mon, 31 Mar 2025 08:54:53 +0000
Subject: [PATCH 15/20] Please consider the following formatting changes

---
 Framework/Core/include/Framework/ASoA.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index c83a7f666bee6..9bf0d8c8e59dc 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1163,9 +1163,10 @@ struct TableIterator : IP, C... {
   template <typename... TA>
   void bindExternalIndices(TA*... current)
   {
-    ([this]<typename... Cs, typename TT>(framework::pack<Cs...>, TT* t){
+    ([this]<typename... Cs, typename TT>(framework::pack<Cs...>, TT* t) {
       (doSetCurrentIndexImpl<Cs>(t), ...);
-    }(framework::pack<C...>{}, current), ...);
+    }(framework::pack<C...>{}, current),
+     ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& bindings)

From 016e431834576f1919c2442eccd29d50d1a8d539 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 16 May 2025 13:18:30 +0200
Subject: [PATCH 16/20] reduce amount of symbols

---
 Framework/Core/include/Framework/ASoA.h       | 221 ++++++------------
 .../include/Framework/GroupedCombinations.h   |  29 +--
 2 files changed, 75 insertions(+), 175 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 9bf0d8c8e59dc..a2cb31bb711e7 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1034,21 +1034,15 @@ concept can_bind = requires(T&& t) {
 template <typename... C>
 concept has_index = (is_indexing_column<C> || ...);
 
-template <is_index_column C>
-  requires(!is_self_index_column<C>)
-consteval auto getBinding() -> typename C::binding_t
-{
-}
-
-template <typename C>
-consteval auto getBinding() -> void
-{
-}
-
 template <typename T, typename... Cs>
 consteval auto inBindings(framework::pack<Cs...>)
 {
-  return framework::has_type_at_v<T>(framework::pack<decltype(getBinding<Cs>())...>{});
+  return framework::has_type_at_v<T>(framework::pack<decltype([]<typename C>(){
+    if constexpr (is_index_column<C> && !is_self_index_column<C>) {
+      return std::declval<typename C::binding_t>();
+    } else {
+      return;
+    } }.template operator()<Cs>())...>{});
 }
 
 template <typename D, typename O, typename IP, typename... C>
@@ -1153,25 +1147,40 @@ struct TableIterator : IP, C... {
     return CL::getCurrentRaw();
   }
 
-  auto getIndexBindings() const
+  auto getIndexBindings() -> std::vector<o2::soa::Binding> const
   {
-    std::vector<o2::soa::Binding> result;
-    (doGetIndexBindingImpl<C>(result), ...);
-    return result;
+    return {[]<soa::is_column CL>(){
+      if constexpr (soa::is_index_column<CL> && !soa::is_self_index_column<CL>) {
+        return o2::soa::Binding{CL::getCurrentRaw()};
+      } else {
+        return o2::soa::Binding{};
+      }
+    }.template operator()<C>()...};
   }
 
   template <typename... TA>
   void bindExternalIndices(TA*... current)
   {
     ([this]<typename... Cs, typename TT>(framework::pack<Cs...>, TT* t) {
-      (doSetCurrentIndexImpl<Cs>(t), ...);
+      ([]<soa::is_column CL, typename TI>(TI* c){
+        if constexpr (soa::is_index_column<CL> && !soa::is_self_index_column<CL>) {
+          CL::setCurrent(c);
+        }
+      }.template operator()<Cs, TT>(t), ...);
     }(framework::pack<C...>{}, current),
      ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& bindings)
   {
-    (doSetCurrentIndexRawImpl<C>(bindings[framework::has_type_at_v<C>(framework::pack<C...>{})]), ...);
+    [&bindings]<size_t... Is>(std::index_sequence<Is...>){
+      ([&bindings](){
+        using column = typename framework::pack_element_t<Is, framework::pack<C...>>;
+        if constexpr (soa::is_index_column<column> && !soa::is_self_index_column<column>) {
+          column::setCurrentRaw(bindings[Is]);
+        }
+      }(), ...);
+    }(std::make_index_sequence<sizeof...(C)>());
   }
 
   template <typename I>
@@ -1179,82 +1188,14 @@ struct TableIterator : IP, C... {
   {
     o2::soa::Binding b;
     b.bind(table);
-    (doSetCurrentInternalImpl<C>(b), ...);
+    ([]<soa::is_column CL>(o2::soa::Binding const& bb){
+      if constexpr(soa::is_self_index_column<CL>) {
+        CL::setCurrentRaw(bb);
+      }
+    }.template operator()<C>(b), ...);
   }
 
  private:
-  /// Overloaded helpers for index manipulations
-  template <soa::is_index_column CL, typename TA>
-    requires(!soa::is_self_index_column<CL>)
-  void doSetCurrentIndexImpl(TA* current)
-  {
-    CL::setCurrent(current);
-  }
-
-  template <soa::is_column CL, typename TA>
-    requires(!soa::is_index_column<CL>)
-  void doSetCurrentIndexImpl(TA*)
-  {
-  }
-
-  template <soa::is_index_column CL>
-    requires(!soa::is_self_index_column<CL>)
-  auto doGetIndexBindingImpl(std::vector<o2::soa::Binding>& bindings) const
-  {
-    bindings.emplace_back(CL::getCurrentRaw());
-  }
-
-  template <soa::is_column CL>
-    requires(!soa::is_index_column<CL>)
-  auto doGetIndexBindingImpl(std::vector<o2::soa::Binding>& bindings) const
-  {
-    bindings.emplace_back();
-  }
-
-  template <soa::is_index_column CL>
-    requires(!soa::is_self_index_column<CL>)
-  void doSetCurrentIndexRawImpl(o2::soa::Binding const& b)
-  {
-    CL::setCurrentRaw(b);
-  }
-
-  template <soa::is_column CL>
-    requires(!soa::is_index_column<CL>)
-  void doSetCurrentIndexRawImpl(o2::soa::Binding const&)
-  {
-  }
-
-  template <soa::is_self_index_column CL>
-  void doSetCurrentInternalImpl(o2::soa::Binding const& b)
-  {
-    CL::setCurrentRaw(b);
-  }
-
-  template <soa::is_column CL>
-    requires(!soa::is_self_index_column<CL>)
-  void doSetCurrentInternalImpl(o2::soa::Binding const&)
-  {
-  }
-
-  /// Overloaded helpers for column binding
-  template <soa::is_persistent_column CL>
-  void doBind()
-  {
-    CL::mColumnIterator.mCurrentPos = &this->mRowIndex;
-  }
-
-  template <soa::is_dynamic_column CL>
-  void doBind()
-  {
-    bindDynamicColumn<CL>(typename CL::bindings_t{});
-  }
-
-  template <soa::is_column CL>
-    requires(!soa::is_persistent_column<CL> && !soa::is_dynamic_column<CL>)
-  void doBind()
-  {
-  }
-
   /// Helper to move at the end of columns which actually have an iterator.
   template <typename... PC>
   void doMoveToEnd(framework::pack<PC...>)
@@ -1267,37 +1208,35 @@ struct TableIterator : IP, C... {
   void bind()
   {
     using namespace o2::soa;
-    (doBind<C>(), ...);
+    ([this]<soa::is_column CL>(){
+      if constexpr (soa::is_persistent_column<CL>) {
+        CL::mColumnIterator.mCurrentPos = &this->mRowIndex;
+      } else if constexpr (soa::is_dynamic_column<CL>) {
+        bindDynamicColumn<CL>(typename CL::bindings_t{});
+      }
+    }.template operator()<C>(), ...);
+
     if constexpr (has_index<C...>) {
       this->setIndices(this->getIndices());
       this->setOffsets(this->getOffsets());
     }
   }
 
-  template <typename DC, typename... B>
-  auto bindDynamicColumn(framework::pack<B...>)
-  {
-    DC::boundIterators = std::make_tuple(getDynamicBinding<B>()...);
-  }
-
   // Sometimes dynamic columns are defined for tables in
   // the hope that it will be joined / extended with another one which provides
   // the full set of bindings. This is to avoid a compilation
   // error if constructor for the table or any other thing involving a missing
   // binding is preinstanciated.
-  template <typename B>
-    requires(can_bind<self_t, B>)
-  decltype(auto) getDynamicBinding()
-  {
-    static_assert(std::same_as<decltype(&(static_cast<B*>(this)->mColumnIterator)), std::decay_t<decltype(B::mColumnIterator)>*>, "foo");
-    return &(static_cast<B*>(this)->mColumnIterator);
-    // return static_cast<std::decay_t<decltype(B::mColumnIterator)>*>(nullptr);
-  }
-
-  template <typename B>
-  decltype(auto) getDynamicBinding()
+  template <typename DC, typename... B>
+  auto bindDynamicColumn(framework::pack<B...>)
   {
-    return static_cast<std::decay_t<decltype(B::mColumnIterator)>*>(nullptr);
+    DC::boundIterators = std::make_tuple([this]<typename Bi>(){
+      if constexpr (can_bind<self_t, Bi>) {
+        return &(static_cast<B*>(this)->mColumnIterator);
+      } else {
+        return static_cast<std::decay_t<decltype(B::mColumnIterator)>*>(nullptr);
+      }
+    }.template operator()<B>()...);
   }
 };
 
@@ -1427,44 +1366,28 @@ static constexpr std::string getLabelFromTypeForKey(std::string const& key)
   O2_BUILTIN_UNREACHABLE();
 }
 
-template <soa::is_index_column CL, typename B>
-  requires(!soa::is_self_index_column<CL>)
-consteval static bool hasIndexToImpl()
-{
-  return o2::soa::is_binding_compatible_v<B, typename CL::binding_t>();
-}
-
-template <soa::is_column CL, typename B>
-  requires(!soa::is_index_column<CL>)
-consteval static bool hasIndexToImpl()
-{
-  return false;
-}
-
 template <typename B, typename... C>
 consteval static bool hasIndexTo(framework::pack<C...>&&)
 {
-  return (hasIndexToImpl<C, B>() || ...);
-}
-
-template <soa::is_index_column CL, typename B>
-  requires(!soa::is_self_index_column<CL>)
-consteval static bool hasSortedIndexToImpl()
-{
-  return CL::sorted && o2::soa::is_binding_compatible_v<B, typename CL::binding_t>();
-}
-
-template <soa::is_column CL, typename B>
-  requires(!soa::is_index_column<CL>)
-consteval static bool hasSortedIndexToImpl()
-{
-  return false;
+  return ([]<soa::is_column CC, typename BB>(){
+    if constexpr (soa::is_index_column<CC> && !soa::is_self_index_column<CC>) {
+      return o2::soa::is_binding_compatible_v<BB, typename CC::binding_t>();
+    } else {
+      return false;
+    }
+  }.template operator()<C, B>() || ...);
 }
 
 template <typename B, typename... C>
 consteval static bool hasSortedIndexTo(framework::pack<C...>&&)
 {
-  return (hasSortedIndexToImpl<C, B>() || ...);
+  return ([]<soa::is_column CC, typename BB>(){
+    if constexpr (soa::is_index_column<CC> && !soa::is_self_index_column<CC>) {
+      return CC::sorted && o2::soa::is_binding_compatible_v<B, typename CC::binding_t>();
+    } else {
+      return false;
+    }
+  }.template operator()<C, B>() || ...);
 }
 
 template <typename B, typename Z>
@@ -2133,22 +2056,14 @@ class Table
     doBindInternalIndicesExplicit(columns_t{}, binding);
   }
 
-  template <soa::is_self_index_column CL>
-  void doBindInternalIndicesExplicitImpl(o2::soa::Binding binding)
-  {
-    static_cast<CL>(mBegin).setCurrentRaw(binding);
-  }
-
-  template <soa::is_column CL>
-    requires(!soa::is_self_index_column<CL>)
-  void doBindInternalIndicesExplicitImpl(o2::soa::Binding)
-  {
-  }
-
   template <typename... Cs>
   void doBindInternalIndicesExplicit(framework::pack<Cs...>, o2::soa::Binding binding)
   {
-    (doBindInternalIndicesExplicitImpl<Cs>(binding), ...);
+    ([this]<soa::is_column CL>(o2::soa::Binding b){
+      if constexpr (soa::is_self_index_column<CL>) {
+        static_cast<CL>(mBegin).setCurrentRaw(b);
+      }
+    }.template operator()<Cs>(binding), ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
diff --git a/Framework/Core/include/Framework/GroupedCombinations.h b/Framework/Core/include/Framework/GroupedCombinations.h
index 6ca7bbef1cbfa..e4c6465515262 100644
--- a/Framework/Core/include/Framework/GroupedCombinations.h
+++ b/Framework/Core/include/Framework/GroupedCombinations.h
@@ -34,29 +34,14 @@ auto interleaveTuples(std::tuple<T1s...>& t1, std::tuple<T2s...>& t2)
   return interleaveTuplesImpl(t1, t2, std::index_sequence_for<T1s...>());
 }
 
-template <soa::is_index_column T, soa::is_table G>
-  requires(!soa::is_self_index_column<T> && o2::soa::is_binding_compatible_v<std::decay_t<G>, typename std::decay_t<T>::binding_t>())
-consteval auto isIndexTo()
-{
-  return std::true_type{};
-}
-
-template <soa::is_index_column T, soa::is_table G>
-  requires(!soa::is_self_index_column<T> && !o2::soa::is_binding_compatible_v<std::decay_t<G>, typename std::decay_t<T>::binding_t>())
-consteval auto isIndexTo()
-{
-  return std::false_type{};
-}
-
-template <soa::is_column T, soa::is_table G>
-  requires(!soa::is_index_column<T>)
-consteval auto isIndexTo()
-{
-  return std::false_type{};
-}
-
 template <typename T, typename G>
-using is_index_to_g_t = decltype(isIndexTo<T, G>());
+using is_index_to_g_t = decltype([](){
+  if constexpr (soa::is_index_column<T> && !soa::is_self_index_column<T>) {
+    return std::conditional_t<o2::soa::is_binding_compatible_v<std::decay_t<G>, typename std::decay_t<T>::binding_t>, std::true_type, std::false_type>{};
+  } else {
+    return std::false_type{};
+  }
+}());
 
 template <typename G, typename A>
 expressions::BindingNode getMatchingIndexNode()

From d52443d993b20861ea1ba0d481bea0a077f96c68 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 16 May 2025 13:30:07 +0200
Subject: [PATCH 17/20] fixup! reduce amount of symbols

---
 Framework/Core/include/Framework/ASoA.h              | 12 ++++++------
 .../Core/include/Framework/GroupedCombinations.h     |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index a2cb31bb711e7..462371453f2d1 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1147,9 +1147,9 @@ struct TableIterator : IP, C... {
     return CL::getCurrentRaw();
   }
 
-  auto getIndexBindings() -> std::vector<o2::soa::Binding> const
+  std::vector<o2::soa::Binding> getIndexBindings() const
   {
-    return {[]<soa::is_column CL>(){
+    return {[this]<soa::is_column CL>(){
       if constexpr (soa::is_index_column<CL> && !soa::is_self_index_column<CL>) {
         return o2::soa::Binding{CL::getCurrentRaw()};
       } else {
@@ -1162,7 +1162,7 @@ struct TableIterator : IP, C... {
   void bindExternalIndices(TA*... current)
   {
     ([this]<typename... Cs, typename TT>(framework::pack<Cs...>, TT* t) {
-      ([]<soa::is_column CL, typename TI>(TI* c){
+      ([this]<soa::is_column CL, typename TI>(TI* c){
         if constexpr (soa::is_index_column<CL> && !soa::is_self_index_column<CL>) {
           CL::setCurrent(c);
         }
@@ -1173,8 +1173,8 @@ struct TableIterator : IP, C... {
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& bindings)
   {
-    [&bindings]<size_t... Is>(std::index_sequence<Is...>){
-      ([&bindings](){
+    [&bindings, this]<size_t... Is>(std::index_sequence<Is...>){
+      ([&bindings, this](){
         using column = typename framework::pack_element_t<Is, framework::pack<C...>>;
         if constexpr (soa::is_index_column<column> && !soa::is_self_index_column<column>) {
           column::setCurrentRaw(bindings[Is]);
@@ -1188,7 +1188,7 @@ struct TableIterator : IP, C... {
   {
     o2::soa::Binding b;
     b.bind(table);
-    ([]<soa::is_column CL>(o2::soa::Binding const& bb){
+    ([this]<soa::is_column CL>(o2::soa::Binding const& bb){
       if constexpr(soa::is_self_index_column<CL>) {
         CL::setCurrentRaw(bb);
       }
diff --git a/Framework/Core/include/Framework/GroupedCombinations.h b/Framework/Core/include/Framework/GroupedCombinations.h
index e4c6465515262..83153d98f6369 100644
--- a/Framework/Core/include/Framework/GroupedCombinations.h
+++ b/Framework/Core/include/Framework/GroupedCombinations.h
@@ -37,7 +37,7 @@ auto interleaveTuples(std::tuple<T1s...>& t1, std::tuple<T2s...>& t2)
 template <typename T, typename G>
 using is_index_to_g_t = decltype([](){
   if constexpr (soa::is_index_column<T> && !soa::is_self_index_column<T>) {
-    return std::conditional_t<o2::soa::is_binding_compatible_v<std::decay_t<G>, typename std::decay_t<T>::binding_t>, std::true_type, std::false_type>{};
+    return std::conditional_t<o2::soa::is_binding_compatible_v<std::decay_t<G>, typename std::decay_t<T>::binding_t>(), std::true_type, std::false_type>{};
   } else {
     return std::false_type{};
   }

From 177ecd1390f910da8618c72f6dbc4e0db4a08d28 Mon Sep 17 00:00:00 2001
From: ALICE Action Bot <alibuild@cern.ch>
Date: Fri, 16 May 2025 11:31:59 +0000
Subject: [PATCH 18/20] Please consider the following formatting changes

---
 Framework/Core/include/Framework/ASoA.h       | 47 +++++++++++--------
 .../include/Framework/GroupedCombinations.h   |  2 +-
 2 files changed, 28 insertions(+), 21 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 462371453f2d1..34790aa42e5b2 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1037,7 +1037,7 @@ concept has_index = (is_indexing_column<C> || ...);
 template <typename T, typename... Cs>
 consteval auto inBindings(framework::pack<Cs...>)
 {
-  return framework::has_type_at_v<T>(framework::pack<decltype([]<typename C>(){
+  return framework::has_type_at_v<T>(framework::pack<decltype([]<typename C>() {
     if constexpr (is_index_column<C> && !is_self_index_column<C>) {
       return std::declval<typename C::binding_t>();
     } else {
@@ -1149,37 +1149,39 @@ struct TableIterator : IP, C... {
 
   std::vector<o2::soa::Binding> getIndexBindings() const
   {
-    return {[this]<soa::is_column CL>(){
+    return { [this]<soa::is_column CL>() {
       if constexpr (soa::is_index_column<CL> && !soa::is_self_index_column<CL>) {
         return o2::soa::Binding{CL::getCurrentRaw()};
       } else {
         return o2::soa::Binding{};
       }
-    }.template operator()<C>()...};
+    }.template operator()<C>()... };
   }
 
   template <typename... TA>
   void bindExternalIndices(TA*... current)
   {
     ([this]<typename... Cs, typename TT>(framework::pack<Cs...>, TT* t) {
-      ([this]<soa::is_column CL, typename TI>(TI* c){
+      ([this]<soa::is_column CL, typename TI>(TI* c) {
         if constexpr (soa::is_index_column<CL> && !soa::is_self_index_column<CL>) {
           CL::setCurrent(c);
         }
-      }.template operator()<Cs, TT>(t), ...);
+      }.template operator()<Cs, TT>(t),
+       ...);
     }(framework::pack<C...>{}, current),
      ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& bindings)
   {
-    [&bindings, this]<size_t... Is>(std::index_sequence<Is...>){
-      ([&bindings, this](){
+    [&bindings, this]<size_t... Is>(std::index_sequence<Is...>) {
+      ([&bindings, this]() {
         using column = typename framework::pack_element_t<Is, framework::pack<C...>>;
         if constexpr (soa::is_index_column<column> && !soa::is_self_index_column<column>) {
           column::setCurrentRaw(bindings[Is]);
         }
-      }(), ...);
+      }(),
+       ...);
     }(std::make_index_sequence<sizeof...(C)>());
   }
 
@@ -1188,11 +1190,12 @@ struct TableIterator : IP, C... {
   {
     o2::soa::Binding b;
     b.bind(table);
-    ([this]<soa::is_column CL>(o2::soa::Binding const& bb){
-      if constexpr(soa::is_self_index_column<CL>) {
+    ([this]<soa::is_column CL>(o2::soa::Binding const& bb) {
+      if constexpr (soa::is_self_index_column<CL>) {
         CL::setCurrentRaw(bb);
       }
-    }.template operator()<C>(b), ...);
+    }.template operator()<C>(b),
+     ...);
   }
 
  private:
@@ -1208,13 +1211,14 @@ struct TableIterator : IP, C... {
   void bind()
   {
     using namespace o2::soa;
-    ([this]<soa::is_column CL>(){
+    ([this]<soa::is_column CL>() {
       if constexpr (soa::is_persistent_column<CL>) {
         CL::mColumnIterator.mCurrentPos = &this->mRowIndex;
       } else if constexpr (soa::is_dynamic_column<CL>) {
         bindDynamicColumn<CL>(typename CL::bindings_t{});
       }
-    }.template operator()<C>(), ...);
+    }.template operator()<C>(),
+     ...);
 
     if constexpr (has_index<C...>) {
       this->setIndices(this->getIndices());
@@ -1230,7 +1234,7 @@ struct TableIterator : IP, C... {
   template <typename DC, typename... B>
   auto bindDynamicColumn(framework::pack<B...>)
   {
-    DC::boundIterators = std::make_tuple([this]<typename Bi>(){
+    DC::boundIterators = std::make_tuple([this]<typename Bi>() {
       if constexpr (can_bind<self_t, Bi>) {
         return &(static_cast<B*>(this)->mColumnIterator);
       } else {
@@ -1369,25 +1373,27 @@ static constexpr std::string getLabelFromTypeForKey(std::string const& key)
 template <typename B, typename... C>
 consteval static bool hasIndexTo(framework::pack<C...>&&)
 {
-  return ([]<soa::is_column CC, typename BB>(){
+  return ([]<soa::is_column CC, typename BB>() {
     if constexpr (soa::is_index_column<CC> && !soa::is_self_index_column<CC>) {
       return o2::soa::is_binding_compatible_v<BB, typename CC::binding_t>();
     } else {
       return false;
     }
-  }.template operator()<C, B>() || ...);
+  }.template operator()<C, B>() ||
+          ...);
 }
 
 template <typename B, typename... C>
 consteval static bool hasSortedIndexTo(framework::pack<C...>&&)
 {
-  return ([]<soa::is_column CC, typename BB>(){
+  return ([]<soa::is_column CC, typename BB>() {
     if constexpr (soa::is_index_column<CC> && !soa::is_self_index_column<CC>) {
       return CC::sorted && o2::soa::is_binding_compatible_v<B, typename CC::binding_t>();
     } else {
       return false;
     }
-  }.template operator()<C, B>() || ...);
+  }.template operator()<C, B>() ||
+          ...);
 }
 
 template <typename B, typename Z>
@@ -2059,11 +2065,12 @@ class Table
   template <typename... Cs>
   void doBindInternalIndicesExplicit(framework::pack<Cs...>, o2::soa::Binding binding)
   {
-    ([this]<soa::is_column CL>(o2::soa::Binding b){
+    ([this]<soa::is_column CL>(o2::soa::Binding b) {
       if constexpr (soa::is_self_index_column<CL>) {
         static_cast<CL>(mBegin).setCurrentRaw(b);
       }
-    }.template operator()<Cs>(binding), ...);
+    }.template operator()<Cs>(binding),
+     ...);
   }
 
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
diff --git a/Framework/Core/include/Framework/GroupedCombinations.h b/Framework/Core/include/Framework/GroupedCombinations.h
index 83153d98f6369..48780a157cf1d 100644
--- a/Framework/Core/include/Framework/GroupedCombinations.h
+++ b/Framework/Core/include/Framework/GroupedCombinations.h
@@ -35,7 +35,7 @@ auto interleaveTuples(std::tuple<T1s...>& t1, std::tuple<T2s...>& t2)
 }
 
 template <typename T, typename G>
-using is_index_to_g_t = decltype([](){
+using is_index_to_g_t = decltype([]() {
   if constexpr (soa::is_index_column<T> && !soa::is_self_index_column<T>) {
     return std::conditional_t<o2::soa::is_binding_compatible_v<std::decay_t<G>, typename std::decay_t<T>::binding_t>(), std::true_type, std::false_type>{};
   } else {

From 2507ed295b5964ec10ca632c3fd1e2ecef16ef21 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 16 May 2025 14:43:20 +0200
Subject: [PATCH 19/20] Fix typo

---
 Framework/Core/include/Framework/ASoA.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 34790aa42e5b2..0a2a785cf4f1a 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1236,9 +1236,9 @@ struct TableIterator : IP, C... {
   {
     DC::boundIterators = std::make_tuple([this]<typename Bi>() {
       if constexpr (can_bind<self_t, Bi>) {
-        return &(static_cast<B*>(this)->mColumnIterator);
+        return &(static_cast<Bi*>(this)->mColumnIterator);
       } else {
-        return static_cast<std::decay_t<decltype(B::mColumnIterator)>*>(nullptr);
+        return static_cast<std::decay_t<decltype(Bi::mColumnIterator)>*>(nullptr);
       }
     }.template operator()<B>()...);
   }

From 8dd344df2909e33c3f5e47a3779a889d769e6a93 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 16 May 2025 22:10:01 +0200
Subject: [PATCH 20/20] attempt to fix

---
 Framework/Core/include/Framework/ASoA.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 0a2a785cf4f1a..7bab9d89c7f9a 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1211,13 +1211,13 @@ struct TableIterator : IP, C... {
   void bind()
   {
     using namespace o2::soa;
-    ([this]<soa::is_column CL>() {
-      if constexpr (soa::is_persistent_column<CL>) {
-        CL::mColumnIterator.mCurrentPos = &this->mRowIndex;
-      } else if constexpr (soa::is_dynamic_column<CL>) {
-        bindDynamicColumn<CL>(typename CL::bindings_t{});
+    ([this]() {
+      if constexpr (soa::is_persistent_column<C>) {
+        C::mColumnIterator.mCurrentPos = &this->mRowIndex;
+      } else if constexpr (soa::is_dynamic_column<C>) {
+        bindDynamicColumn<C>(typename C::bindings_t{});
       }
-    }.template operator()<C>(),
+    }(),
      ...);
 
     if constexpr (has_index<C...>) {