diff --git a/core/foundation/CMakeLists.txt b/core/foundation/CMakeLists.txt
index d877d99c76c79..138b67ffd6000 100644
--- a/core/foundation/CMakeLists.txt
+++ b/core/foundation/CMakeLists.txt
@@ -18,3 +18,8 @@ ROOT_OBJECT_LIBRARY(Foundation_Stage1 ${sources}) # used by rootcling_stage1
 set_target_properties(Foundation_Stage1 PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} ${CLING_CXXFLAGS}")
 
 ROOT_INSTALL_HEADERS()
+
+if(testing)
+  add_subdirectory(test)
+endif()
+
diff --git a/core/foundation/inc/ROOT/TTypeTraits.hxx b/core/foundation/inc/ROOT/TTypeTraits.hxx
deleted file mode 100644
index df5108162739d..0000000000000
--- a/core/foundation/inc/ROOT/TTypeTraits.hxx
+++ /dev/null
@@ -1,30 +0,0 @@
-// @(#)root/foundation:
-// Author: Axel Naumann, 2017-06-02
-
-/*************************************************************************
- * Copyright (C) 1995-2017, Rene Brun and Fons Rademakers.               *
- * All rights reserved.                                                  *
- *                                                                       *
- * For the licensing terms see $ROOTSYS/LICENSE.                         *
- * For the list of contributors see $ROOTSYS/README/CREDITS.             *
- *************************************************************************/
-
-#ifndef ROOT_TTypeTraits
-#define ROOT_TTypeTraits
-
-#include <type_traits>
-
-namespace ROOT{
-
-///\class ROOT::TypeTraits::
-template <class T>
-class IsSmartOrDumbPtr: public std::integral_constant<bool, std::is_pointer<T>::value> {};
-
-template <class P>
-class IsSmartOrDumbPtr<std::shared_ptr<P>>: public std::true_type {};
-
-template <class P>
-class IsSmartOrDumbPtr<std::unique_ptr<P>>: public std::true_type {};
-
-}
-#endif //ROOT_TTypeTraits
diff --git a/core/foundation/inc/ROOT/TypeTraits.hxx b/core/foundation/inc/ROOT/TypeTraits.hxx
new file mode 100644
index 0000000000000..8e4b6099a1d1e
--- /dev/null
+++ b/core/foundation/inc/ROOT/TypeTraits.hxx
@@ -0,0 +1,165 @@
+// @(#)root/foundation:
+// Author: Axel Naumann, Enrico Guiraud, June 2017
+
+/*************************************************************************
+ * Copyright (C) 1995-2017, Rene Brun and Fons Rademakers.               *
+ * All rights reserved.                                                  *
+ *                                                                       *
+ * For the licensing terms see $ROOTSYS/LICENSE.                         *
+ * For the list of contributors see $ROOTSYS/README/CREDITS.             *
+ *************************************************************************/
+
+#ifndef ROOT_TypeTraits
+#define ROOT_TypeTraits
+
+#include <memory> // shared_ptr, unique_ptr for IsSmartOrDumbPtr
+#include <type_traits>
+#include <vector> // for IsContainer
+
+namespace ROOT {
+
+/// ROOT type_traits extensions
+namespace TypeTraits {
+
+///\class ROOT::TypeTraits::
+template <class T>
+class IsSmartOrDumbPtr : public std::integral_constant<bool, std::is_pointer<T>::value> {
+};
+
+template <class P>
+class IsSmartOrDumbPtr<std::shared_ptr<P>> : public std::true_type {
+};
+
+template <class P>
+class IsSmartOrDumbPtr<std::unique_ptr<P>> : public std::true_type {
+};
+
+/// Check for container traits.
+template <typename T>
+struct IsContainer {
+   using Test_t = typename std::decay<T>::type;
+
+   template <typename A>
+   static constexpr bool Test(A *pt, A const *cpt = nullptr, decltype(pt->begin()) * = nullptr,
+                              decltype(pt->end()) * = nullptr, decltype(cpt->begin()) * = nullptr,
+                              decltype(cpt->end()) * = nullptr, typename A::iterator *pi = nullptr,
+                              typename A::const_iterator *pci = nullptr)
+   {
+      using It_t = typename A::iterator;
+      using CIt_t = typename A::const_iterator;
+      using V_t = typename A::value_type;
+      return std::is_same<Test_t, std::vector<bool>>::value ||
+             (std::is_same<decltype(pt->begin()), It_t>::value && std::is_same<decltype(pt->end()), It_t>::value &&
+              std::is_same<decltype(cpt->begin()), CIt_t>::value && std::is_same<decltype(cpt->end()), CIt_t>::value &&
+              std::is_same<decltype(**pi), V_t &>::value && std::is_same<decltype(**pci), V_t const &>::value);
+   }
+
+   template <typename A>
+   static constexpr bool Test(...)
+   {
+      return false;
+   }
+
+   static constexpr bool value = Test<Test_t>(nullptr);
+};
+
+/// Lightweight storage for a collection of types.
+/// Differently from std::tuple, no instantiation of objects of stored types is performed
+template <typename... Types>
+struct TypeList {
+   static constexpr std::size_t list_size = sizeof...(Types);
+};
+
+/// Extract types from the signature of a callable object.
+template <typename T>
+struct CallableTraits {
+   using arg_types = typename CallableTraits<decltype(&T::operator())>::arg_types;
+   using arg_types_nodecay = typename CallableTraits<decltype(&T::operator())>::arg_types_nodecay;
+   using ret_type = typename CallableTraits<decltype(&T::operator())>::ret_type;
+};
+
+// lambdas and std::function
+template <typename R, typename T, typename... Args>
+struct CallableTraits<R (T::*)(Args...) const> {
+   using arg_types = TypeList<typename std::decay<Args>::type...>;
+   using arg_types_nodecay = TypeList<Args...>;
+   using ret_type = R;
+};
+
+// mutable lambdas and functor classes
+template <typename R, typename T, typename... Args>
+struct CallableTraits<R (T::*)(Args...)> {
+   using arg_types = TypeList<typename std::decay<Args>::type...>;
+   using arg_types_nodecay = TypeList<Args...>;
+   using ret_type = R;
+};
+
+// function pointers
+template <typename R, typename... Args>
+struct CallableTraits<R (*)(Args...)> {
+   using arg_types = TypeList<typename std::decay<Args>::type...>;
+   using arg_types_nodecay = TypeList<Args...>;
+   using ret_type = R;
+};
+
+// free functions
+template <typename R, typename... Args>
+struct CallableTraits<R(Args...)> {
+   using arg_types = TypeList<typename std::decay<Args>::type...>;
+   using arg_types_nodecay = TypeList<Args...>;
+   using ret_type = R;
+};
+
+// Return first of a variadic list of types.
+template <typename T, typename... Rest>
+struct TakeFirstType {
+   using type = T;
+};
+
+template <typename... Types>
+using TakeFirstType_t = typename TakeFirstType<Types...>::type;
+
+// Remove first type from a variadic list of types, return a TypeList containing the rest.
+// e.g. RemoveFirst_t<A,B,C> is TypeList<B,C>
+template <typename T, typename... Rest>
+struct RemoveFirst {
+   using type = TypeList<Rest...>;
+};
+
+template <typename... Args>
+using RemoveFirst_t = typename RemoveFirst<Args...>::type;
+
+/// Return first of possibly many template parameters.
+/// For non-template types, the result is the type itself.
+/// e.g. TakeFirstParameter<U<A,B>> is A
+///      TakeFirstParameter<T> is T
+template <typename T>
+struct TakeFirstParameter {
+   using type = void;
+};
+
+template <template <typename...> class Template, typename T, typename... Rest>
+struct TakeFirstParameter<Template<T, Rest...>> {
+   using type = T;
+};
+
+template <typename T>
+using TakeFirstParameter_t = typename TakeFirstParameter<T>::type;
+
+/// Remove first of possibly many template parameters.
+/// e.g. RemoveFirstParameter_t<U<A,B>> is U<B>
+template <typename>
+struct RemoveFirstParameter {
+};
+
+template <typename T, template <typename...> class U, typename... Rest>
+struct RemoveFirstParameter<U<T, Rest...>> {
+   using type = U<Rest...>;
+};
+
+template <typename T>
+using RemoveFirstParameter_t = typename RemoveFirstParameter<T>::type;
+
+} // ns ROOT
+} // ns TypeTraits
+#endif // ROOT_TTypeTraits
diff --git a/core/foundation/test/CMakeLists.txt b/core/foundation/test/CMakeLists.txt
new file mode 100644
index 0000000000000..9f5d3020d249d
--- /dev/null
+++ b/core/foundation/test/CMakeLists.txt
@@ -0,0 +1,2 @@
+ROOT_ADD_GTEST(testTypeTraits testTypeTraits.cxx LIBRARIES Core)
+
diff --git a/core/foundation/test/testTypeTraits.cxx b/core/foundation/test/testTypeTraits.cxx
new file mode 100644
index 0000000000000..9aaf126f1ed97
--- /dev/null
+++ b/core/foundation/test/testTypeTraits.cxx
@@ -0,0 +1,137 @@
+#include "ROOT/TypeTraits.hxx"
+
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+#include "gtest/gtest.h"
+
+using namespace ROOT::TypeTraits;
+
+TEST(TypeTraits, TypeList)
+{
+   static_assert(TypeList<>::list_size == 0, "");
+   static_assert(TypeList<void>::list_size == 1, "");
+   static_assert((TypeList<int, double *>::list_size) == 2, "");
+}
+
+TEST(TypeTraits, TakeFirstType)
+{
+   ::testing::StaticAssertTypeEq<TakeFirstType_t<int, void, double *>, int>();
+   ::testing::StaticAssertTypeEq<TakeFirstType_t<TypeList<int, int>, TypeList<void>>, TypeList<int, int>>();
+}
+
+TEST(TypeTraits, RemoveFirst)
+{
+   ::testing::StaticAssertTypeEq<RemoveFirst_t<int, void, double *>, TypeList<void, double *>>();
+   ::testing::StaticAssertTypeEq<RemoveFirst_t<TypeList<int, int>, TypeList<void>>, TypeList<TypeList<void>>>();
+}
+
+TEST(TypeTraits, TakeFirstParameter)
+{
+   ::testing::StaticAssertTypeEq<TakeFirstParameter_t<TypeList<int, void>>, int>();
+   ::testing::StaticAssertTypeEq<TakeFirstParameter_t<std::tuple<void>>, void>();
+}
+
+TEST(TypeTraits, RemoveFirstParameter)
+{
+   ::testing::StaticAssertTypeEq<RemoveFirstParameter_t<TypeList<int, void>>, TypeList<void>>();
+   ::testing::StaticAssertTypeEq<RemoveFirstParameter_t<std::tuple<void>>, std::tuple<>>();
+}
+
+TEST(TypeTraits, IsContainer)
+{
+   static_assert(IsContainer<std::vector<int>>::value, "");
+   static_assert(IsContainer<std::vector<bool>>::value, "");
+   static_assert(IsContainer<std::tuple<int, int>>::value == false, "");
+}
+
+/******** helper objects ***********/
+struct Dummy {
+};
+
+int freeFun1(int)
+{
+   return 0;
+}
+
+Dummy freeFun2(Dummy &, int *, const std::vector<Dummy> &)
+{
+   return Dummy();
+}
+
+struct Functor1 {
+   void operator()(int) { return; }
+};
+
+struct Functor2 {
+   Dummy operator()(Dummy &, int *, const std::vector<Dummy> &) { return Dummy(); }
+};
+/***********************************/
+
+TEST(TypeTraits, CallableTraits)
+{
+   // check CallableTraits with one arg, two args, return type, nodecaytypes
+   // free function
+   ::testing::StaticAssertTypeEq<TypeList<int>, CallableTraits<decltype(freeFun1)>::arg_types>();
+   ::testing::StaticAssertTypeEq<TypeList<int>, CallableTraits<decltype(freeFun1)>::arg_types_nodecay>();
+   ::testing::StaticAssertTypeEq<int, CallableTraits<decltype(freeFun1)>::ret_type>();
+   ::testing::StaticAssertTypeEq<TypeList<Dummy, int *, std::vector<Dummy>>,
+                                 CallableTraits<decltype(freeFun2)>::arg_types>();
+   ::testing::StaticAssertTypeEq<TypeList<Dummy &, int *, const std::vector<Dummy> &>,
+                                 CallableTraits<decltype(freeFun2)>::arg_types_nodecay>();
+   ::testing::StaticAssertTypeEq<Dummy, CallableTraits<decltype(freeFun2)>::ret_type>();
+
+   // function pointer
+   auto freeFun1Ptr = &freeFun1;
+   auto freeFun2Ptr = &freeFun2;
+   ::testing::StaticAssertTypeEq<TypeList<int>, CallableTraits<decltype(freeFun1Ptr)>::arg_types>();
+   ::testing::StaticAssertTypeEq<TypeList<int>, CallableTraits<decltype(freeFun1Ptr)>::arg_types_nodecay>();
+   ::testing::StaticAssertTypeEq<int, CallableTraits<decltype(freeFun1Ptr)>::ret_type>();
+   ::testing::StaticAssertTypeEq<TypeList<Dummy, int *, std::vector<Dummy>>,
+                                 CallableTraits<decltype(freeFun2Ptr)>::arg_types>();
+   ::testing::StaticAssertTypeEq<TypeList<Dummy &, int *, const std::vector<Dummy> &>,
+                                 CallableTraits<decltype(freeFun2Ptr)>::arg_types_nodecay>();
+   ::testing::StaticAssertTypeEq<Dummy, CallableTraits<decltype(freeFun2Ptr)>::ret_type>();
+
+   // functor class
+   ::testing::StaticAssertTypeEq<TypeList<int>, CallableTraits<Functor1>::arg_types>();
+   ::testing::StaticAssertTypeEq<TypeList<int>, CallableTraits<Functor1>::arg_types_nodecay>();
+   ::testing::StaticAssertTypeEq<void, CallableTraits<Functor1>::ret_type>();
+   ::testing::StaticAssertTypeEq<TypeList<Dummy, int *, std::vector<Dummy>>, CallableTraits<Functor2>::arg_types>();
+   ::testing::StaticAssertTypeEq<TypeList<Dummy &, int *, const std::vector<Dummy> &>,
+                                 CallableTraits<Functor2>::arg_types_nodecay>();
+   ::testing::StaticAssertTypeEq<Dummy, CallableTraits<Functor2>::ret_type>();
+
+   // mutable lambda
+   auto boolvec = std::make_shared<std::vector<bool>>(2, false);
+   auto lambda1 = [boolvec](const bool b) mutable -> std::vector<bool> & {
+      boolvec->at(0) = b;
+      return *boolvec;
+   };
+
+   // lambda
+   auto lambda2 = [](Dummy &, int *, const std::vector<Dummy> &) { return Dummy(); };
+   ::testing::StaticAssertTypeEq<TypeList<bool>, CallableTraits<decltype(lambda1)>::arg_types>();
+   ::testing::StaticAssertTypeEq<TypeList<bool>, CallableTraits<decltype(lambda1)>::arg_types_nodecay>();
+   ::testing::StaticAssertTypeEq<std::vector<bool> &, CallableTraits<decltype(lambda1)>::ret_type>();
+   ::testing::StaticAssertTypeEq<TypeList<Dummy, int *, std::vector<Dummy>>,
+                                 CallableTraits<decltype(lambda2)>::arg_types>();
+   ::testing::StaticAssertTypeEq<TypeList<Dummy &, int *, const std::vector<Dummy> &>,
+                                 CallableTraits<decltype(lambda2)>::arg_types_nodecay>();
+   ::testing::StaticAssertTypeEq<Dummy, CallableTraits<decltype(lambda2)>::ret_type>();
+
+   // std::function
+   // masking signature int(int) of freeFunc1
+   std::function<int(double)> stdFun1(freeFun1);
+   // masking signature of lambda2
+   std::function<Dummy(Dummy &, int *, const std::vector<Dummy> &)> stdFun2(lambda2);
+   ::testing::StaticAssertTypeEq<TypeList<double>, CallableTraits<decltype(stdFun1)>::arg_types>();
+   ::testing::StaticAssertTypeEq<TypeList<double>, CallableTraits<decltype(stdFun1)>::arg_types_nodecay>();
+   ::testing::StaticAssertTypeEq<int, CallableTraits<decltype(stdFun1)>::ret_type>();
+   ::testing::StaticAssertTypeEq<TypeList<Dummy, int *, std::vector<Dummy>>,
+                                 CallableTraits<decltype(stdFun2)>::arg_types>();
+   ::testing::StaticAssertTypeEq<TypeList<Dummy &, int *, const std::vector<Dummy> &>,
+                                 CallableTraits<decltype(stdFun2)>::arg_types_nodecay>();
+   ::testing::StaticAssertTypeEq<Dummy, CallableTraits<decltype(stdFun2)>::ret_type>();
+}
diff --git a/graf2d/gpad/v7/inc/ROOT/TCanvas.hxx b/graf2d/gpad/v7/inc/ROOT/TCanvas.hxx
index df35207e9e685..7565fe9a20a11 100644
--- a/graf2d/gpad/v7/inc/ROOT/TCanvas.hxx
+++ b/graf2d/gpad/v7/inc/ROOT/TCanvas.hxx
@@ -102,17 +102,19 @@ public:
   }
 
    /// Add a copy of something to be painted.
-   template<class T, class = typename std::enable_if<!ROOT::IsSmartOrDumbPtr<T>::value>::type>
+   template<class T, class = typename std::enable_if<!ROOT::TypeTraits::IsSmartOrDumbPtr<T>::value>::type>
    void Draw(const T& what) {
      // Requires GetDrawable(what, options) to be known!
      fPrimitives.emplace_back(GetDrawable(std::make_unique<T>(what)));
    }
 
    /// Add a copy of something to be painted, with options.
-   template<class T, class OPTIONS, class = typename std::enable_if<!ROOT::IsSmartOrDumbPtr<T>::value>::type>
-   void Draw(const T& what, const OPTIONS &options) {
-     // Requires GetDrawable(what, options) to be known!
-     fPrimitives.emplace_back(GetDrawable(std::make_unique<T>(what), options));
+   template <class T, class OPTIONS,
+             class = typename std::enable_if<!ROOT::TypeTraits::IsSmartOrDumbPtr<T>::value>::type>
+   void Draw(const T &what, const OPTIONS &options)
+   {
+      // Requires GetDrawable(what, options) to be known!
+      fPrimitives.emplace_back(GetDrawable(std::make_unique<T>(what), options));
    }
 
   /// Remove an object from the list of primitives.
diff --git a/tree/treeplayer/inc/ROOT/TDFActionHelpers.hxx b/tree/treeplayer/inc/ROOT/TDFActionHelpers.hxx
index da66eef3c923e..58e47f525cd8a 100644
--- a/tree/treeplayer/inc/ROOT/TDFActionHelpers.hxx
+++ b/tree/treeplayer/inc/ROOT/TDFActionHelpers.hxx
@@ -12,6 +12,7 @@
 #define ROOT_TDFOPERATIONS
 
 #include "ROOT/TBufferMerger.hxx" // for SnapshotHelper
+#include "ROOT/TypeTraits.hxx"
 #include "ROOT/TDFUtils.hxx"
 #include "ROOT/TThreadedObject.hxx"
 #include "TH1.h"
@@ -29,6 +30,7 @@
 namespace ROOT {
 namespace Internal {
 namespace TDF {
+using namespace ROOT::TypeTraits;
 
 using Count_t = unsigned long;
 using Hist_t = ::TH1F;
@@ -38,7 +40,7 @@ class ForeachSlotHelper {
    F fCallable;
 
 public:
-   using BranchTypes_t = typename TRemoveFirst<typename TFunctionTraits<F>::Args_t>::Types_t;
+   using BranchTypes_t = RemoveFirstParameter_t<typename CallableTraits<F>::arg_types>;
    ForeachSlotHelper(F &&f) : fCallable(f) {}
 
    void Init(TTreeReader*, unsigned int) {}
@@ -47,7 +49,7 @@ public:
    void Exec(unsigned int slot, Args &&... args)
    {
       // check that the decayed types of Args are the same as the branch types
-      static_assert(std::is_same<TTypeList<typename std::decay<Args>::type...>, BranchTypes_t>::value, "");
+      static_assert(std::is_same<TypeList<typename std::decay<Args>::type...>, BranchTypes_t>::value, "");
       fCallable(slot, std::forward<Args>(args)...);
    }
 
@@ -59,7 +61,7 @@ class CountHelper {
    std::vector<Count_t> fCounts;
 
 public:
-   using BranchTypes_t = TTypeList<>;
+   using BranchTypes_t = TypeList<>;
    CountHelper(const std::shared_ptr<unsigned int> &resultCount, unsigned int nSlots);
    void Init(TTreeReader*, unsigned int) {}
    void Exec(unsigned int slot);
@@ -88,7 +90,7 @@ public:
    void Exec(unsigned int slot, double v);
    void Exec(unsigned int slot, double v, double w);
 
-   template <typename T, typename std::enable_if<TIsContainer<T>::fgValue, int>::type = 0>
+   template <typename T, typename std::enable_if<IsContainer<T>::value, int>::type = 0>
    void Exec(unsigned int slot, const T &vs)
    {
       auto &thisBuf = fBuffers[slot];
@@ -99,7 +101,7 @@ public:
    }
 
    template <typename T, typename W,
-             typename std::enable_if<TIsContainer<T>::fgValue && TIsContainer<W>::fgValue, int>::type = 0>
+             typename std::enable_if<IsContainer<T>::value && IsContainer<W>::value, int>::type = 0>
    void Exec(unsigned int slot, const T &vs, const W &ws)
    {
       auto &thisBuf = fBuffers[slot];
@@ -167,7 +169,7 @@ public:
       fTo->GetAtSlotUnchecked(slot)->Fill(x0, x1, x2, x3);
    }
 
-   template <typename X0, typename std::enable_if<TIsContainer<X0>::fgValue, int>::type = 0>
+   template <typename X0, typename std::enable_if<IsContainer<X0>::value, int>::type = 0>
    void Exec(unsigned int slot, const X0 &x0s)
    {
       auto thisSlotH = fTo->GetAtSlotUnchecked(slot);
@@ -177,7 +179,7 @@ public:
    }
 
    template <typename X0, typename X1,
-             typename std::enable_if<TIsContainer<X0>::fgValue && TIsContainer<X1>::fgValue, int>::type = 0>
+             typename std::enable_if<IsContainer<X0>::value && IsContainer<X1>::value, int>::type = 0>
    void Exec(unsigned int slot, const X0 &x0s, const X1 &x1s)
    {
       auto thisSlotH = fTo->GetAtSlotUnchecked(slot);
@@ -193,8 +195,8 @@ public:
    }
 
    template <typename X0, typename X1, typename X2,
-             typename std::enable_if<
-                TIsContainer<X0>::fgValue && TIsContainer<X1>::fgValue && TIsContainer<X2>::fgValue, int>::type = 0>
+             typename std::enable_if<IsContainer<X0>::value && IsContainer<X1>::value && IsContainer<X2>::value,
+                                     int>::type = 0>
    void Exec(unsigned int slot, const X0 &x0s, const X1 &x1s, const X2 &x2s)
    {
       auto thisSlotH = fTo->GetAtSlotUnchecked(slot);
@@ -210,8 +212,8 @@ public:
       }
    }
    template <typename X0, typename X1, typename X2, typename X3,
-             typename std::enable_if<TIsContainer<X0>::fgValue && TIsContainer<X1>::fgValue &&
-                                        TIsContainer<X2>::fgValue && TIsContainer<X3>::fgValue,
+             typename std::enable_if<IsContainer<X0>::value && IsContainer<X1>::value && IsContainer<X2>::value &&
+                                        IsContainer<X3>::value,
                                      int>::type = 0>
    void Exec(unsigned int slot, const X0 &x0s, const X1 &x1s, const X2 &x2s, const X3 &x3s)
    {
@@ -238,7 +240,7 @@ class TakeHelper {
    std::vector<std::shared_ptr<COLL>> fColls;
 
 public:
-   using BranchTypes_t = TTypeList<T>;
+   using BranchTypes_t = TypeList<T>;
    TakeHelper(const std::shared_ptr<COLL> &resultColl, unsigned int nSlots)
    {
       fColls.emplace_back(resultColl);
@@ -247,13 +249,13 @@ public:
 
    void Init(TTreeReader*, unsigned int) {}
 
-   template <typename V, typename std::enable_if<!TIsContainer<V>::fgValue, int>::type = 0>
+   template <typename V, typename std::enable_if<!IsContainer<V>::value, int>::type = 0>
    void Exec(unsigned int slot, V v)
    {
       fColls[slot]->emplace_back(v);
    }
 
-   template <typename V, typename std::enable_if<TIsContainer<V>::fgValue, int>::type = 0>
+   template <typename V, typename std::enable_if<IsContainer<V>::value, int>::type = 0>
    void Exec(unsigned int slot, const V &vs)
    {
       auto thisColl = fColls[slot];
@@ -279,7 +281,7 @@ class TakeHelper<T, std::vector<T>> {
    std::vector<std::shared_ptr<std::vector<T>>> fColls;
 
 public:
-   using BranchTypes_t = TTypeList<T>;
+   using BranchTypes_t = TypeList<T>;
    TakeHelper(const std::shared_ptr<std::vector<T>> &resultColl, unsigned int nSlots)
    {
       fColls.emplace_back(resultColl);
@@ -292,13 +294,13 @@ public:
 
    void Init(TTreeReader*, unsigned int) {}
 
-   template <typename V, typename std::enable_if<!TIsContainer<V>::fgValue, int>::type = 0>
+   template <typename V, typename std::enable_if<!IsContainer<V>::value, int>::type = 0>
    void Exec(unsigned int slot, V v)
    {
       fColls[slot]->emplace_back(v);
    }
 
-   template <typename V, typename std::enable_if<TIsContainer<V>::fgValue, int>::type = 0>
+   template <typename V, typename std::enable_if<IsContainer<V>::value, int>::type = 0>
    void Exec(unsigned int slot, const V &vs)
    {
       auto thisColl = fColls[slot];
@@ -325,7 +327,7 @@ class ReduceHelper {
    std::vector<T> fReduceObjs;
 
 public:
-   using BranchTypes_t = TTypeList<T>;
+   using BranchTypes_t = TypeList<T>;
    ReduceHelper(F &&f, const std::shared_ptr<T> &reduceRes, unsigned int nSlots)
       : fReduceFun(std::move(f)), fReduceRes(reduceRes), fReduceObjs(nSlots, *reduceRes)
    {
@@ -352,7 +354,7 @@ public:
 
    void Exec(unsigned int slot, double v);
 
-   template <typename T, typename std::enable_if<TIsContainer<T>::fgValue, int>::type = 0>
+   template <typename T, typename std::enable_if<IsContainer<T>::value, int>::type = 0>
    void Exec(unsigned int slot, const T &vs)
    {
       for (auto &&v : vs) fMins[slot] = std::min((double)v, fMins[slot]);
@@ -376,7 +378,7 @@ public:
    void Init(TTreeReader*, unsigned int) {}
    void Exec(unsigned int slot, double v);
 
-   template <typename T, typename std::enable_if<TIsContainer<T>::fgValue, int>::type = 0>
+   template <typename T, typename std::enable_if<IsContainer<T>::value, int>::type = 0>
    void Exec(unsigned int slot, const T &vs)
    {
       for (auto &&v : vs) fMaxs[slot] = std::max((double)v, fMaxs[slot]);
@@ -401,7 +403,7 @@ public:
    void Init(TTreeReader*, unsigned int) {}
    void Exec(unsigned int slot, double v);
 
-   template <typename T, typename std::enable_if<TIsContainer<T>::fgValue, int>::type = 0>
+   template <typename T, typename std::enable_if<IsContainer<T>::value, int>::type = 0>
    void Exec(unsigned int slot, const T &vs)
    {
       for (auto &&v : vs) {
@@ -455,14 +457,14 @@ public:
    void Exec(unsigned int /* slot */, BranchTypes &... values)
    {
       if (fIsFirstEvent) {
-         using ind_t = typename TGenStaticSeq<sizeof...(BranchTypes)>::Type_t;
+         using ind_t = GenStaticSeq_t<sizeof...(BranchTypes)>;
          SetBranches(&values..., ind_t());
       }
       fOutputTree->Fill();
    }
 
    template <int... S>
-   void SetBranches(BranchTypes *... branchAddresses, TStaticSeq<S...> /*dummy*/)
+   void SetBranches(BranchTypes *... branchAddresses, StaticSeq<S...> /*dummy*/)
    {
       // hack to call TTree::Branch on all variadic template arguments
       std::initializer_list<int> expander = {(fOutputTree->Branch(fBranchNames[S].c_str(), branchAddresses), 0)..., 0};
@@ -485,7 +487,7 @@ class SnapshotHelperMT {
    const std::string fTreeName; // name of output tree
    const ColumnNames_t fBranchNames;
 public:
-   using BranchTypes_t = TTypeList<BranchTypes...>;
+   using BranchTypes_t = TypeList<BranchTypes...>;
    SnapshotHelperMT(unsigned int nSlots, const std::string &filename, const std::string &dirname,
                     const std::string &treename, const ColumnNames_t &bnames)
       : fNSlots(nSlots), fMerger(new ROOT::Experimental::TBufferMerger(filename.c_str(), "RECREATE")),
@@ -526,7 +528,7 @@ public:
    void Exec(unsigned int slot, BranchTypes &... values)
    {
       if (fIsFirstEvent[slot]) {
-         using ind_t = typename TGenStaticSeq<sizeof...(BranchTypes)>::Type_t;
+         using ind_t = GenStaticSeq_t<sizeof...(BranchTypes)>;
          SetBranches(slot, &values..., ind_t());
          fIsFirstEvent[slot] = 0;
       }
@@ -537,7 +539,7 @@ public:
    }
 
    template <int... S>
-   void SetBranches(unsigned int slot, BranchTypes *... branchAddresses, TStaticSeq<S...> /*dummy*/)
+   void SetBranches(unsigned int slot, BranchTypes *... branchAddresses, StaticSeq<S...> /*dummy*/)
    {
       // hack to call TTree::Branch on all variadic template arguments
       std::initializer_list<int> expander = {
diff --git a/tree/treeplayer/inc/ROOT/TDFInterface.hxx b/tree/treeplayer/inc/ROOT/TDFInterface.hxx
index 4e337e13b20b6..b0470ebd18447 100644
--- a/tree/treeplayer/inc/ROOT/TDFInterface.hxx
+++ b/tree/treeplayer/inc/ROOT/TDFInterface.hxx
@@ -80,6 +80,7 @@ namespace Experimental {
 namespace TDF {
 namespace TDFDetail = ROOT::Detail::TDF;
 namespace TDFInternal = ROOT::Internal::TDF;
+namespace TTraits = ROOT::TypeTraits;
 
 /**
 * \class ROOT::Experimental::TDF::TInterface
@@ -127,7 +128,7 @@ public:
       TDFInternal::CheckFilter(f);
       auto df = GetDataFrameChecked();
       const ColumnNames_t &defBl = df->GetDefaultBranches();
-      auto nArgs = TDFInternal::TFunctionTraits<F>::Args_t::fgSize;
+      auto nArgs = TTraits::CallableTraits<F>::arg_types::list_size;
       const ColumnNames_t &actualBl = TDFInternal::PickBranchNames(nArgs, bn, defBl);
       using DFF_t = TDFDetail::TFilter<F, Proxied>;
       auto FilterPtr = std::make_shared<DFF_t>(std::move(f), actualBl, *fProxiedPtr, name);
@@ -207,7 +208,7 @@ public:
       auto df = GetDataFrameChecked();
       TDFInternal::CheckTmpBranch(name, df->GetTree());
       const ColumnNames_t &defBl = df->GetDefaultBranches();
-      auto nArgs = TDFInternal::TFunctionTraits<F>::Args_t::fgSize;
+      auto nArgs = TTraits::CallableTraits<F>::arg_types::list_size;
       const ColumnNames_t &actualBl = TDFInternal::PickBranchNames(nArgs, bl, defBl);
       using DFB_t = TDFDetail::TCustomColumn<F, Proxied>;
       const std::string nameInt(name);
@@ -242,10 +243,9 @@ public:
    ///
    /// This function returns a `TDataFrame` built with the output tree as a source.
    template <typename... BranchTypes>
-   TInterface<TLoopManager> Snapshot(std::string_view treename, std::string_view filename,
-                                     const ColumnNames_t &bnames)
+   TInterface<TLoopManager> Snapshot(std::string_view treename, std::string_view filename, const ColumnNames_t &bnames)
    {
-      using TypeInd_t = typename TDFInternal::TGenStaticSeq<sizeof...(BranchTypes)>::Type_t;
+      using TypeInd_t = TDFInternal::GenStaticSeq_t<sizeof...(BranchTypes)>;
       return SnapshotImpl<BranchTypes...>(treename, filename, bnames, TypeInd_t());
    }
 
@@ -257,8 +257,7 @@ public:
    ///
    /// This function returns a `TDataFrame` built with the output tree as a source.
    /// The types of the branches are automatically inferred and do not need to be specified.
-   TInterface<TLoopManager> Snapshot(std::string_view treename, std::string_view filename,
-                                     const ColumnNames_t &bnames)
+   TInterface<TLoopManager> Snapshot(std::string_view treename, std::string_view filename, const ColumnNames_t &bnames)
    {
       auto df = GetDataFrameChecked();
       auto tree = df->GetTree();
@@ -299,7 +298,7 @@ public:
       const auto isEmptyRegex = 0 == theRegexSize;
       // This is to avoid cases where branches called b1, b2, b3 are all matched by expression "b"
       if (theRegexSize > 0 && theRegex[0] != '^') theRegex = "^" + theRegex;
-      if (theRegexSize > 0 && theRegex[theRegexSize-1] != '$') theRegex = theRegex + "$";
+      if (theRegexSize > 0 && theRegex[theRegexSize - 1] != '$') theRegex = theRegex + "$";
 
       ColumnNames_t selectedColumns;
       selectedColumns.reserve(32);
@@ -375,9 +374,9 @@ public:
    template <typename F>
    void Foreach(F f, const ColumnNames_t &bl = {})
    {
-      using Args_t = typename TDFInternal::TFunctionTraits<decltype(f)>::ArgsNoDecay_t;
-      using Ret_t = typename TDFInternal::TFunctionTraits<decltype(f)>::Ret_t;
-      ForeachSlot(TDFInternal::AddSlotParameter<Ret_t>(f, Args_t()), bl);
+      using arg_types = typename TTraits::CallableTraits<decltype(f)>::arg_types_nodecay;
+      using ret_type = typename TTraits::CallableTraits<decltype(f)>::ret_type;
+      ForeachSlot(TDFInternal::AddSlotParameter<ret_type>(f, arg_types()), bl);
    }
 
    ////////////////////////////////////////////////////////////////////////////
@@ -401,7 +400,7 @@ public:
    {
       auto df = GetDataFrameChecked();
       const ColumnNames_t &defBl = df->GetDefaultBranches();
-      auto nArgs = TDFInternal::TFunctionTraits<F>::Args_t::fgSize;
+      auto nArgs = TTraits::CallableTraits<F>::arg_types::list_size;
       const ColumnNames_t &actualBl = TDFInternal::PickBranchNames(nArgs - 1, bl, defBl);
       using Op_t = TDFInternal::ForeachSlotHelper<F>;
       using DFA_t = TDFInternal::TAction<Op_t, Proxied>;
@@ -426,7 +425,7 @@ public:
    ///
    /// This action is *lazy*: upon invocation of this method the calculation is
    /// booked but not executed. See TResultProxy documentation.
-   template <typename F, typename T = typename TDFInternal::TFunctionTraits<F>::Ret_t>
+   template <typename F, typename T = typename TTraits::CallableTraits<F>::ret_type>
    TResultProxy<T> Reduce(F f, std::string_view branchName = {})
    {
       static_assert(std::is_default_constructible<T>::value,
@@ -443,11 +442,11 @@ public:
    /// \param[in] initValue The reduced object is initialised to this value rather than being default-constructed
    ///
    /// See the description of the other Reduce overload for more information.
-   template <typename F, typename T = typename TDFInternal::TFunctionTraits<F>::Ret_t>
+   template <typename F, typename T = typename TTraits::CallableTraits<F>::ret_type>
    TResultProxy<T> Reduce(F f, std::string_view branchName, const T &initValue)
    {
-      using Args_t = typename TDFInternal::TFunctionTraits<F>::Args_t;
-      TDFInternal::CheckReduce(f, Args_t());
+      using arg_types = typename TTraits::CallableTraits<F>::arg_types;
+      TDFInternal::CheckReduce(f, arg_types());
       auto df = GetDataFrameChecked();
       unsigned int nSlots = df->GetNSlots();
       auto bl = GetBranchNames<T>({branchName}, "reduce branch values");
@@ -689,8 +688,7 @@ public:
    /// booked but not executed. See TResultProxy documentation.
    /// The user gives up ownership of the model profile object.
    template <typename V1 = TDFDetail::TInferType, typename V2 = TDFDetail::TInferType>
-   TResultProxy<::TProfile> Profile1D(::TProfile &&model, std::string_view v1Name = "",
-                                      std::string_view v2Name = "")
+   TResultProxy<::TProfile> Profile1D(::TProfile &&model, std::string_view v1Name = "", std::string_view v2Name = "")
    {
       auto h = std::make_shared<::TProfile>(std::move(model));
       if (!TDFInternal::HistoUtils<::TProfile>::HasAxisLimits(*h)) {
@@ -909,7 +907,7 @@ private:
 
    /// Returns the default branches if needed, takes care of the error handling.
    template <typename T1, typename T2 = void, typename T3 = void, typename T4 = void>
-   ColumnNames_t GetBranchNames(const std::vector<std::string_view>& bl, std::string_view actionNameForErr)
+   ColumnNames_t GetBranchNames(const std::vector<std::string_view> &bl, std::string_view actionNameForErr)
    {
       constexpr auto isT2Void = std::is_same<T2, void>::value;
       constexpr auto isT3Void = std::is_same<T3, void>::value;
@@ -941,7 +939,7 @@ private:
                      ActionType *)
    {
       using Op_t = TDFInternal::FillTOHelper<ActionResultType>;
-      using DFA_t = TDFInternal::TAction<Op_t, Proxied, TDFInternal::TTypeList<BranchTypes...>>;
+      using DFA_t = TDFInternal::TAction<Op_t, Proxied, TTraits::TypeList<BranchTypes...>>;
       auto df = GetDataFrameChecked();
       df->Book(std::make_shared<DFA_t>(Op_t(h, nSlots), bl, *fProxiedPtr));
    }
@@ -956,11 +954,11 @@ private:
 
       if (hasAxisLimits) {
          using Op_t = TDFInternal::FillTOHelper<::TH1F>;
-         using DFA_t = TDFInternal::TAction<Op_t, Proxied, TDFInternal::TTypeList<BranchTypes...>>;
+         using DFA_t = TDFInternal::TAction<Op_t, Proxied, TTraits::TypeList<BranchTypes...>>;
          df->Book(std::make_shared<DFA_t>(Op_t(h, nSlots), bl, *fProxiedPtr));
       } else {
          using Op_t = TDFInternal::FillHelper;
-         using DFA_t = TDFInternal::TAction<Op_t, Proxied, TDFInternal::TTypeList<BranchTypes...>>;
+         using DFA_t = TDFInternal::TAction<Op_t, Proxied, TTraits::TypeList<BranchTypes...>>;
          df->Book(std::make_shared<DFA_t>(Op_t(h, nSlots), bl, *fProxiedPtr));
       }
    }
@@ -971,7 +969,7 @@ private:
                      TDFInternal::ActionTypes::Min *)
    {
       using Op_t = TDFInternal::MinHelper;
-      using DFA_t = TDFInternal::TAction<Op_t, Proxied, TDFInternal::TTypeList<BranchType>>;
+      using DFA_t = TDFInternal::TAction<Op_t, Proxied, TTraits::TypeList<BranchType>>;
       auto df = GetDataFrameChecked();
       df->Book(std::make_shared<DFA_t>(Op_t(minV, nSlots), bl, *fProxiedPtr));
    }
@@ -982,7 +980,7 @@ private:
                      TDFInternal::ActionTypes::Max *)
    {
       using Op_t = TDFInternal::MaxHelper;
-      using DFA_t = TDFInternal::TAction<Op_t, Proxied, TDFInternal::TTypeList<BranchType>>;
+      using DFA_t = TDFInternal::TAction<Op_t, Proxied, TTraits::TypeList<BranchType>>;
       auto df = GetDataFrameChecked();
       df->Book(std::make_shared<DFA_t>(Op_t(maxV, nSlots), bl, *fProxiedPtr));
    }
@@ -993,7 +991,7 @@ private:
                      TDFInternal::ActionTypes::Mean *)
    {
       using Op_t = TDFInternal::MeanHelper;
-      using DFA_t = TDFInternal::TAction<Op_t, Proxied, TDFInternal::TTypeList<BranchType>>;
+      using DFA_t = TDFInternal::TAction<Op_t, Proxied, TTraits::TypeList<BranchType>>;
       auto df = GetDataFrameChecked();
       df->Book(std::make_shared<DFA_t>(Op_t(meanV, nSlots), bl, *fProxiedPtr));
    }
@@ -1070,7 +1068,7 @@ protected:
    /// the TTreeReaderValue/TemporaryBranch
    template <typename... BranchTypes, int... S>
    TInterface<TLoopManager> SnapshotImpl(std::string_view treename, std::string_view filename,
-                                         const ColumnNames_t &bnames, TDFInternal::TStaticSeq<S...> /*dummy*/)
+                                         const ColumnNames_t &bnames, TDFInternal::StaticSeq<S...> /*dummy*/)
    {
       // check for input sanity
       const auto templateParamsN = sizeof...(S);
@@ -1108,7 +1106,7 @@ protected:
       if (!ROOT::IsImplicitMTEnabled()) {
          // single-thread snapshot
          using Op_t = TDFInternal::SnapshotHelper<BranchTypes...>;
-         using DFA_t = TDFInternal::TAction<Op_t, Proxied, TDFInternal::TTypeList<BranchTypes...>>;
+         using DFA_t = TDFInternal::TAction<Op_t, Proxied, TTraits::TypeList<BranchTypes...>>;
          actionPtr.reset(new DFA_t(Op_t(filenameInt, dirnameInt, treenameInt, bnames), bnames, *fProxiedPtr));
       } else {
          // multi-thread snapshot
diff --git a/tree/treeplayer/inc/ROOT/TDFNodes.hxx b/tree/treeplayer/inc/ROOT/TDFNodes.hxx
index cc28db2fd7727..4129731a76ea8 100644
--- a/tree/treeplayer/inc/ROOT/TDFNodes.hxx
+++ b/tree/treeplayer/inc/ROOT/TDFNodes.hxx
@@ -11,6 +11,7 @@
 #ifndef ROOT_TDFNODES
 #define ROOT_TDFNODES
 
+#include "ROOT/TypeTraits.hxx"
 #include "ROOT/TDFUtils.hxx"
 #include "ROOT/RArrayView.hxx"
 #include "ROOT/TSpinMutex.hxx"
@@ -32,6 +33,7 @@ class TActionBase;
 
 namespace Detail {
 namespace TDF {
+using namespace ROOT::TypeTraits;
 namespace TDFInternal = ROOT::Internal::TDF;
 
 // forward declarations for TLoopManager
@@ -137,7 +139,7 @@ class TColumnValue {
    // following line is equivalent to pseudo-code: ProxyParam_t == array_view<U> ? U : T
    // ReaderValueOrArray_t is a TTreeReaderValue<T> unless T is array_view<U>
    using ProxyParam_t = typename std::conditional<std::is_same<ReaderValueOrArray_t<T>, TTreeReaderValue<T>>::value, T,
-                                                  ExtractType_t<T>>::type;
+                                                  TakeFirstParameter_t<T>>::type;
    std::unique_ptr<TTreeReaderValue<T>> fReaderValue{nullptr}; //< Owning ptr to a TTreeReaderValue. Used for
                                                                /// non-temporary columns and T != std::array_view<U>
    std::unique_ptr<TTreeReaderArray<ProxyParam_t>> fReaderArray{nullptr}; //< Owning ptr to a TTreeReaderArray. Used for
@@ -196,7 +198,7 @@ struct TTDFValueTuple {
 };
 
 template <typename... BranchTypes>
-struct TTDFValueTuple<TTypeList<BranchTypes...>> {
+struct TTDFValueTuple<TypeList<BranchTypes...>> {
    using type = std::tuple<TColumnValue<BranchTypes>...>;
 };
 
@@ -220,7 +222,7 @@ public:
 
 template <typename Helper, typename PrevDataFrame, typename BranchTypes_t = typename Helper::BranchTypes_t>
 class TAction final : public TActionBase {
-   using TypeInd_t = typename TGenStaticSeq<BranchTypes_t::fgSize>::Type_t;
+   using TypeInd_t = TDFInternal::GenStaticSeq_t<BranchTypes_t::list_size>;
 
    Helper fHelper;
    const ColumnNames_t fBranches;
@@ -250,7 +252,7 @@ public:
    }
 
    template <int... S>
-   void Exec(unsigned int slot, Long64_t entry, TStaticSeq<S...>)
+   void Exec(unsigned int slot, Long64_t entry, TDFInternal::StaticSeq<S...>)
    {
       (void)entry; // avoid bogus 'unused parameter' warning in gcc4.9
       fHelper.Exec(slot, std::get<S>(fValues[slot]).Get(entry)...);
@@ -294,13 +296,13 @@ public:
 
 template <typename F, typename PrevData>
 class TCustomColumn final : public TCustomColumnBase {
-   using BranchTypes_t = typename TDFInternal::TFunctionTraits<F>::Args_t;
-   using TypeInd_t = typename TDFInternal::TGenStaticSeq<BranchTypes_t::fgSize>::Type_t;
-   using Ret_t = typename TDFInternal::TFunctionTraits<F>::Ret_t;
+   using BranchTypes_t = typename CallableTraits<F>::arg_types;
+   using TypeInd_t = TDFInternal::GenStaticSeq_t<BranchTypes_t::list_size>;
+   using ret_type = typename CallableTraits<F>::ret_type;
 
    F fExpression;
    const ColumnNames_t fBranches;
-   std::vector<std::unique_ptr<Ret_t>> fLastResultPtr;
+   std::vector<std::unique_ptr<ret_type>> fLastResultPtr;
    PrevData &fPrevData;
    std::vector<Long64_t> fLastCheckedEntry = {-1};
 
@@ -333,14 +335,15 @@ public:
       }
    }
 
-   const std::type_info &GetTypeId() const { return typeid(Ret_t); }
+   const std::type_info &GetTypeId() const { return typeid(ret_type); }
 
    void CreateSlots(unsigned int nSlots) final
    {
       fValues.resize(nSlots);
       fLastCheckedEntry.resize(nSlots, -1);
       fLastResultPtr.resize(nSlots);
-      std::generate(fLastResultPtr.begin(), fLastResultPtr.end(), []() { return std::unique_ptr<Ret_t>(new Ret_t()); });
+      std::generate(fLastResultPtr.begin(), fLastResultPtr.end(),
+                    []() { return std::unique_ptr<ret_type>(new ret_type()); });
    }
 
    bool CheckFilters(unsigned int slot, Long64_t entry) final
@@ -350,8 +353,7 @@ public:
    }
 
    template <int... S, typename... BranchTypes>
-   void UpdateHelper(unsigned int slot, Long64_t entry, TDFInternal::TStaticSeq<S...>,
-                     TDFInternal::TTypeList<BranchTypes...>)
+   void UpdateHelper(unsigned int slot, Long64_t entry, TDFInternal::StaticSeq<S...>, TypeList<BranchTypes...>)
    {
       *fLastResultPtr[slot] = fExpression(std::get<S>(fValues[slot]).Get(entry)...);
    }
@@ -400,8 +402,8 @@ public:
 
 template <typename FilterF, typename PrevDataFrame>
 class TFilter final : public TFilterBase {
-   using BranchTypes_t = typename TDFInternal::TFunctionTraits<FilterF>::Args_t;
-   using TypeInd_t = typename TDFInternal::TGenStaticSeq<BranchTypes_t::fgSize>::Type_t;
+   using BranchTypes_t = typename CallableTraits<FilterF>::arg_types;
+   using TypeInd_t = TDFInternal::GenStaticSeq_t<BranchTypes_t::list_size>;
 
    FilterF fFilter;
    const ColumnNames_t fBranches;
@@ -447,7 +449,7 @@ public:
    }
 
    template <int... S>
-   bool CheckFilterHelper(unsigned int slot, Long64_t entry, TDFInternal::TStaticSeq<S...>)
+   bool CheckFilterHelper(unsigned int slot, Long64_t entry, TDFInternal::StaticSeq<S...>)
    {
       return fFilter(std::get<S>(fValues[slot]).Get(entry)...);
    }
diff --git a/tree/treeplayer/inc/ROOT/TDFUtils.hxx b/tree/treeplayer/inc/ROOT/TDFUtils.hxx
index 5649d91281972..ba37441025809 100644
--- a/tree/treeplayer/inc/ROOT/TDFUtils.hxx
+++ b/tree/treeplayer/inc/ROOT/TDFUtils.hxx
@@ -11,6 +11,7 @@
 #ifndef ROOT_TDFUTILS
 #define ROOT_TDFUTILS
 
+#include "ROOT/TypeTraits.hxx"
 #include "ROOT/RArrayView.hxx"
 #include "TH1.h"
 #include "TTreeReaderArray.h"
@@ -30,10 +31,20 @@ class TTreeReader;
 
 namespace ROOT {
 
+// fwd declaration for IsV7Hist
+namespace Experimental {
+template <int D, typename P, template <int, typename, template <typename> class> class... S>
+class THist;
+} // ns Experimental
+
 namespace Detail {
 namespace TDF {
 using ColumnNames_t = std::vector<std::string>;
-class TCustomColumnBase; // fwd decl for ColumnName2ColumnTypeName
+
+// fwd decl for ColumnName2ColumnTypeName
+class TCustomColumnBase;
+
+// type used for tag dispatching
 struct TInferType {
 };
 } // end ns Detail
@@ -41,127 +52,34 @@ struct TInferType {
 
 namespace Internal {
 namespace TDF {
+using namespace ROOT::TypeTraits;
 using namespace ROOT::Detail::TDF;
 
-template <typename... Types>
-struct TTypeList {
-   static constexpr std::size_t fgSize = sizeof...(Types);
-};
-
-// extract parameter types from a callable object
-template <typename T>
-struct TFunctionTraits {
-   using Args_t = typename TFunctionTraits<decltype(&T::operator())>::Args_t;
-   using ArgsNoDecay_t = typename TFunctionTraits<decltype(&T::operator())>::ArgsNoDecay_t;
-   using Ret_t = typename TFunctionTraits<decltype(&T::operator())>::Ret_t;
-};
-
-// lambdas and std::function
-template <typename R, typename T, typename... Args>
-struct TFunctionTraits<R (T::*)(Args...) const> {
-   using Args_t = TTypeList<typename std::decay<Args>::type...>;
-   using ArgsNoDecay_t = TTypeList<Args...>;
-   using Ret_t = R;
-};
-
-// mutable lambdas and functor classes
-template <typename R, typename T, typename... Args>
-struct TFunctionTraits<R (T::*)(Args...)> {
-   using Args_t = TTypeList<typename std::decay<Args>::type...>;
-   using ArgsNoDecay_t = TTypeList<Args...>;
-   using Ret_t = R;
-};
-
-// function pointers
-template <typename R, typename... Args>
-struct TFunctionTraits<R (*)(Args...)> {
-   using Args_t = TTypeList<typename std::decay<Args>::type...>;
-   using ArgsNoDecay_t = TTypeList<Args...>;
-   using Ret_t = R;
+/// Compile-time integer sequence generator
+/// e.g. calling GenStaticSeq<3>::type() instantiates a StaticSeq<0,1,2>
+template <int...>
+struct StaticSeq {
 };
 
-// free functions
-template <typename R, typename... Args>
-struct TFunctionTraits<R(Args...)> {
-   using Args_t = TTypeList<typename std::decay<Args>::type...>;
-   using ArgsNoDecay_t = TTypeList<Args...>;
-   using Ret_t = R;
+template <int N, int... S>
+struct GenStaticSeq : GenStaticSeq<N - 1, N - 1, S...> {
 };
 
-// remove first type from TTypeList
-template <typename>
-struct TRemoveFirst {
+template <int... S>
+struct GenStaticSeq<0, S...> {
+   using type = StaticSeq<S...>;
 };
 
-template <typename T, typename... Args>
-struct TRemoveFirst<TTypeList<T, Args...>> {
-   using Types_t = TTypeList<Args...>;
-};
+template <int... S>
+using GenStaticSeq_t = typename GenStaticSeq<S...>::type;
 
 // return wrapper around f that prepends an `unsigned int slot` parameter
 template <typename R, typename F, typename... Args>
-std::function<R(unsigned int, Args...)> AddSlotParameter(F &f, TTypeList<Args...>)
+std::function<R(unsigned int, Args...)> AddSlotParameter(F &f, TypeList<Args...>)
 {
    return [f](unsigned int, Args... a) -> R { return f(a...); };
 }
 
-// compile-time integer sequence generator
-// e.g. calling TGenStaticSeq<3>::type() instantiates a TStaticSeq<0,1,2>
-template <int...>
-struct TStaticSeq {
-};
-
-template <int N, int... S>
-struct TGenStaticSeq : TGenStaticSeq<N - 1, N - 1, S...> {
-};
-
-template <int... S>
-struct TGenStaticSeq<0, S...> {
-   using Type_t = TStaticSeq<S...>;
-};
-
-template <typename T>
-struct TIsContainer {
-   using Test_t = typename std::decay<T>::type;
-
-   template <typename A>
-   static constexpr bool Test(A *pt, A const *cpt = nullptr, decltype(pt->begin()) * = nullptr,
-                              decltype(pt->end()) * = nullptr, decltype(cpt->begin()) * = nullptr,
-                              decltype(cpt->end()) * = nullptr, typename A::iterator *pi = nullptr,
-                              typename A::const_iterator *pci = nullptr)
-   {
-      using It_t = typename A::iterator;
-      using CIt_t = typename A::const_iterator;
-      using V_t = typename A::value_type;
-      return std::is_same<Test_t, std::vector<bool>>::value ||
-             (std::is_same<decltype(pt->begin()), It_t>::value && std::is_same<decltype(pt->end()), It_t>::value &&
-              std::is_same<decltype(cpt->begin()), CIt_t>::value && std::is_same<decltype(cpt->end()), CIt_t>::value &&
-              std::is_same<decltype(**pi), V_t &>::value && std::is_same<decltype(**pci), V_t const &>::value);
-   }
-
-   template <typename A>
-   static constexpr bool Test(...)
-   {
-      return false;
-   }
-
-   static const bool fgValue = Test<Test_t>(nullptr);
-};
-
-// Extract first of possibly many template parameters. For non-template types, the result is the type itself
-template <typename T>
-struct TExtractType {
-   using type = T;
-};
-
-template <typename T, template <typename...> class U, typename... Extras>
-struct TExtractType<U<T, Extras...>> {
-   using type = T;
-};
-
-template <typename T>
-using ExtractType_t = typename TExtractType<T>::type;
-
 template <typename BranchType, typename... Rest>
 struct TNeedJitting {
    static constexpr bool value = TNeedJitting<Rest...>::value;
@@ -213,7 +131,7 @@ using ReaderValueOrArray_t = typename TReaderValueOrArray<T>::Proxy_t;
 template <typename TDFValueTuple, int... S>
 void InitTDFValues(unsigned int slot, TDFValueTuple &valueTuple, TTreeReader *r, const ColumnNames_t &bn,
                    const ColumnNames_t &tmpbn,
-                   const std::map<std::string, std::shared_ptr<TCustomColumnBase>> &tmpBranches, TStaticSeq<S...>)
+                   const std::map<std::string, std::shared_ptr<TCustomColumnBase>> &tmpBranches, StaticSeq<S...>)
 {
    // isTmpBranch has length bn.size(). Elements are true if the corresponding
    // branch is a temporary branch created with Define, false if they are
@@ -237,7 +155,7 @@ void InitTDFValues(unsigned int slot, TDFValueTuple &valueTuple, TTreeReader *r,
 template <typename Filter>
 void CheckFilter(Filter &)
 {
-   using FilterRet_t = typename TDF::TFunctionTraits<Filter>::Ret_t;
+   using FilterRet_t = typename TDF::CallableTraits<Filter>::ret_type;
    static_assert(std::is_same<FilterRet_t, bool>::value, "filter functions must return a bool");
 }
 
@@ -248,15 +166,15 @@ void CheckTmpBranch(std::string_view branchName, TTree *treePtr);
 /// - takes exactly two arguments of the same type
 /// - has a return value of the same type as the arguments
 template <typename F, typename T>
-void CheckReduce(F &, TTypeList<T, T>)
+void CheckReduce(F &, TypeList<T, T>)
 {
-   using Ret_t = typename TFunctionTraits<F>::Ret_t;
-   static_assert(std::is_same<Ret_t, T>::value, "reduce function must have return type equal to argument type");
+   using ret_type = typename CallableTraits<F>::ret_type;
+   static_assert(std::is_same<ret_type, T>::value, "reduce function must have return type equal to argument type");
    return;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-/// This overload of CheckReduce is called if T is not a TTypeList<T,T>
+/// This overload of CheckReduce is called if T is not a TypeList<T,T>
 template <typename F, typename T>
 void CheckReduce(F &, T)
 {
@@ -287,12 +205,17 @@ struct Fill {
 };
 }
 
-template <typename T, bool ISV7HISTO = !std::is_base_of<TH1, T>::value>
-struct TIsV7Histo {
-   const static bool fgValue = ISV7HISTO;
+/// Check whether a histogram type is a classic or v7 histogram.
+template <typename T>
+struct IsV7Hist : public std::false_type {
+   static_assert(std::is_base_of<TH1, T>::value, "not implemented for this type");
+};
+
+template <int D, typename P, template <int, typename, template <typename> class> class... S>
+struct IsV7Hist<ROOT::Experimental::THist<D, P, S...>> : public std::true_type {
 };
 
-template <typename T, bool ISV7HISTO = TIsV7Histo<T>::fgValue>
+template <typename T, bool ISV7HISTO = IsV7Hist<T>::value>
 struct HistoUtils {
    static void SetCanExtendAllAxes(T &h) { h.SetCanExtend(::TH1::kAllAxes); }
    static bool HasAxisLimits(T &h)
diff --git a/tree/treeplayer/inc/ROOT/TDataFrame.hxx b/tree/treeplayer/inc/ROOT/TDataFrame.hxx
index ee881e1da37e7..080cf2713e9d0 100644
--- a/tree/treeplayer/inc/ROOT/TDataFrame.hxx
+++ b/tree/treeplayer/inc/ROOT/TDataFrame.hxx
@@ -16,6 +16,7 @@ The ROOT Data Frame allows to analyse data stored in TTrees with a high level in
 #ifndef ROOT_TDATAFRAME
 #define ROOT_TDATAFRAME
 
+#include "ROOT/TypeTraits.hxx"
 #include "ROOT/TDFInterface.hxx"
 #include "ROOT/TDFNodes.hxx"
 #include "ROOT/TDFUtils.hxx"
@@ -32,6 +33,7 @@ namespace ROOT {
 namespace Experimental {
 namespace TDFDetail = ROOT::Detail::TDF;
 namespace TDFInternal = ROOT::Internal::TDF;
+namespace TTraits = ROOT::TypeTraits;
 
 class TDataFrame : public TDF::TInterface<TDFDetail::TLoopManager> {
    using ColumnNames_t = TDFDetail::ColumnNames_t;
@@ -50,15 +52,14 @@ public:
    /// See TInterface for the documentation of the
    /// methods available.
    template <typename FILENAMESCOLL = std::vector<std::string>,
-             typename std::enable_if<TDFInternal::TIsContainer<FILENAMESCOLL>::fgValue, int>::type = 0>
-   TDataFrame(std::string_view treeName, const FILENAMESCOLL &filenamescoll,
-              const ColumnNames_t &defaultBranches = {});
+             typename std::enable_if<TTraits::IsContainer<FILENAMESCOLL>::value, int>::type = 0>
+   TDataFrame(std::string_view treeName, const FILENAMESCOLL &filenamescoll, const ColumnNames_t &defaultBranches = {});
    TDataFrame(std::string_view treeName, ::TDirectory *dirPtr, const ColumnNames_t &defaultBranches = {});
    TDataFrame(TTree &tree, const ColumnNames_t &defaultBranches = {});
    TDataFrame(Long64_t numEntries);
 };
 
-template <typename FILENAMESCOLL, typename std::enable_if<TDFInternal::TIsContainer<FILENAMESCOLL>::fgValue, int>::type>
+template <typename FILENAMESCOLL, typename std::enable_if<TTraits::IsContainer<FILENAMESCOLL>::value, int>::type>
 TDataFrame::TDataFrame(std::string_view treeName, const FILENAMESCOLL &filenamescoll,
                        const ColumnNames_t &defaultBranches)
    : TDF::TInterface<TDFDetail::TLoopManager>(std::make_shared<TDFDetail::TLoopManager>(nullptr, defaultBranches))
diff --git a/tree/treeplayer/inc/ROOT/TResultProxy.hxx b/tree/treeplayer/inc/ROOT/TResultProxy.hxx
index b39e97a89fc34..f33cc527a585c 100644
--- a/tree/treeplayer/inc/ROOT/TResultProxy.hxx
+++ b/tree/treeplayer/inc/ROOT/TResultProxy.hxx
@@ -11,8 +11,8 @@
 #ifndef ROOT_TRESULTPROXY
 #define ROOT_TRESULTPROXY
 
+#include "ROOT/TypeTraits.hxx"
 #include "ROOT/TDFNodes.hxx"
-#include "ROOT/TDFUtils.hxx"
 
 #include <memory>
 
@@ -39,6 +39,7 @@ namespace Experimental {
 namespace TDF {
 namespace TDFInternal = ROOT::Internal::TDF;
 namespace TDFDetail = ROOT::Detail::TDF;
+namespace TTraits = ROOT::TypeTraits;
 
 /// Smart pointer for the return type of actions
 /**
@@ -62,7 +63,7 @@ If iteration is not supported by the type of the proxied object, a compilation e
 template <typename T>
 class TResultProxy {
    /// \cond HIDDEN_SYMBOLS
-   template <typename V, bool isCont = TDFInternal::TIsContainer<V>::fgValue>
+   template <typename V, bool isCont = TTraits::IsContainer<V>::value>
    struct TIterationHelper {
       using Iterator_t = void;
       void GetBegin(const V &) { static_assert(sizeof(V) == 0, "It does not make sense to ask begin for this class."); }
@@ -110,10 +111,7 @@ public:
 
    /// Get a const reference to the encapsulated object.
    /// Triggers event loop and execution of all actions booked in the associated TLoopManager.
-   const T &GetValue()
-   {
-      return *Get();
-   }
+   const T &GetValue() { return *Get(); }
 
    /// Get a pointer to the encapsulated object.
    /// Triggers event loop and execution of all actions booked in the associated TLoopManager.