diff --git a/Core/include/Acts/Propagator/ActorConcepts.hpp b/Core/include/Acts/Propagator/ActorConcepts.hpp
index abbe1ae1d8a0..8e2d56e79836 100644
--- a/Core/include/Acts/Propagator/ActorConcepts.hpp
+++ b/Core/include/Acts/Propagator/ActorConcepts.hpp
@@ -17,6 +17,11 @@ namespace Acts {
 template <typename actor_t>
 concept ActorHasResult = requires { typename actor_t::result_type; };
 
+template <typename actor_t>
+struct ActorHasResultStruct {
+  static constexpr bool value = ActorHasResult<actor_t>;
+};
+
 template <typename actor_t, typename propagator_state_t, typename stepper_t,
           typename navigator_t, typename... Args>
 concept ActorHasActWithoutResult = requires(
diff --git a/Core/include/Acts/Propagator/ActorList.hpp b/Core/include/Acts/Propagator/ActorList.hpp
index 1101caf2682c..19ad73786d48 100644
--- a/Core/include/Acts/Propagator/ActorList.hpp
+++ b/Core/include/Acts/Propagator/ActorList.hpp
@@ -9,16 +9,14 @@
 #pragma once
 
 #include "Acts/Propagator/detail/actor_list_implementation.hpp"
-#include "Acts/Utilities/detail/MPL/all_of.hpp"
-#include "Acts/Utilities/detail/MPL/has_duplicates.hpp"
-#include "Acts/Utilities/detail/MPL/type_collector.hpp"
-
-#include <boost/hana/type.hpp>
-#include <boost/hana/unpack.hpp>
-
-namespace hana = boost::hana;
+#include "Acts/Utilities/TypeList.hpp"
 
 namespace Acts {
+/// @brief Extract the result type of an actor
+template <typename T>
+struct ActorResultTypeExtractor {
+  using type = T::result_type;
+};
 
 /// @brief ActorList implementation to be used with the propagator
 ///
@@ -26,18 +24,20 @@ namespace Acts {
 /// to define a list of different actors_t that are each
 /// executed during the stepping procedure
 template <typename... actors_t>
-  requires(
-      detail::all_of_v<std::is_default_constructible<actors_t>::value...> &&
-      detail::all_of_v<std::is_copy_constructible<actors_t>::value...> &&
-      detail::all_of_v<std::is_move_constructible<actors_t>::value...> &&
-      !detail::has_duplicates_v<actors_t...>)
+  requires((std::is_default_constructible<actors_t>::value && ...) &&
+           (std::is_copy_constructible<actors_t>::value && ...) &&
+           (std::is_move_constructible<actors_t>::value && ...) &&
+           ((Types::count<actors_t, TypeList<actors_t...>>::value == 1) && ...))
 struct ActorList {
   /// @cond
   // This uses the type collector and unpacks using the `R` meta function
+  // template <template <typename...> class R>
   template <template <typename...> class R>
-  using result_type = typename decltype(hana::unpack(
-      detail::type_collector_t<detail::result_type_extractor, actors_t...>,
-      hana::template_<R>))::type;
+  using result_type = typename Types::apply<
+      R, typename Types::map<ActorResultTypeExtractor,
+                             typename Types::filter<ActorHasResultStruct,
+                                                    actors_t...>::type>::type>::
+      type;
   /// @endcond
 
   /// Default constructor
diff --git a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
index 0e406f561ba7..8d236789aed1 100644
--- a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
+++ b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
@@ -9,7 +9,6 @@
 #pragma once
 
 #include "Acts/Propagator/ActorConcepts.hpp"
-#include "Acts/Utilities/detail/MPL/type_collector.hpp"
 
 #include <tuple>
 #include <utility>
@@ -36,7 +35,7 @@ struct actor_caller {
     if constexpr (ActorHasActWithResult<actor_t, propagator_state_t, stepper_t,
                                         navigator_t, Args...>) {
       actor.act(state, stepper, navigator,
-                state.template get<detail::result_type_t<actor_t>>(),
+                state.template get<typename actor_t::result_type>(),
                 std::forward<Args>(args)...);
       return;
     }
@@ -60,7 +59,7 @@ struct actor_caller {
                                           stepper_t, navigator_t, Args...>) {
       return actor.checkAbort(
           state, stepper, navigator,
-          state.template get<detail::result_type_t<actor_t>>(),
+          state.template get<typename actor_t::result_type>(),
           std::forward<Args>(args)...);
     }
 
diff --git a/Core/include/Acts/Utilities/TypeList.hpp b/Core/include/Acts/Utilities/TypeList.hpp
index 7c700223d5b2..5d8045ae2782 100644
--- a/Core/include/Acts/Utilities/TypeList.hpp
+++ b/Core/include/Acts/Utilities/TypeList.hpp
@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <concepts>
 #include <cstddef>
 #include <type_traits>
 
@@ -93,5 +94,65 @@ template <typename L, typename N>
 using push_front = typename doPushFront<N, L>::type;
 /// @}
 
+/// Filter a list of types
+/// @{
+template <template <typename> typename Pred, typename... Ts>
+struct filter {};
+
+template <template <typename> typename Pred>
+struct filter<Pred> {
+  using type = TypeList<>;
+};
+
+template <typename T, typename... Ts, template <typename> typename Pred>
+struct filter<Pred, T, Ts...> {
+  using _next_type = filter<Pred, Ts...>::type;
+  using type =
+      std::conditional_t<Pred<T>::value, push_front<_next_type, T>, _next_type>;
+};
+/// @}
+
+/// Apply a typelist to a type function
+/// @{
+template <template <typename...> typename F, typename T>
+struct apply {};
+
+template <template <typename...> typename F, typename... Ts>
+struct apply<F, TypeList<Ts...>> {
+  using type = F<Ts...>;
+};
+/// @}
+
+/// Apply a mapping function to a type list
+/// @{
+template <template <typename> typename F, typename T>
+struct map {};
+
+template <template <typename> typename F, typename... Ts>
+struct map<F, TypeList<Ts...>> {
+  using type = TypeList<typename F<Ts>::type...>;
+};
+/// @}
+
+/// Count the number of times a type occurs in a type list
+/// @{
+template <typename T, typename L>
+struct count {};
+
+template <typename T>
+struct count<T, TypeList<>> {
+  static constexpr std::size_t value = 0;
+};
+
+template <typename T, typename U, typename... Us>
+struct count<T, TypeList<U, Us...>> {
+  static constexpr std::size_t value =
+      std::conditional_t<std::is_same_v<T, U>,
+                         std::integral_constant<std::size_t, 1>,
+                         std::integral_constant<std::size_t, 0>>::value +
+      count<T, TypeList<Us...>>::value;
+};
+/// @}
+
 }  // namespace Types
 }  // namespace Acts
diff --git a/Core/include/Acts/Utilities/detail/Extendable.hpp b/Core/include/Acts/Utilities/detail/Extendable.hpp
index 66ce1c795793..7b0d97f23c28 100644
--- a/Core/include/Acts/Utilities/detail/Extendable.hpp
+++ b/Core/include/Acts/Utilities/detail/Extendable.hpp
@@ -8,8 +8,6 @@
 
 #pragma once
 
-#include "Acts/Utilities/detail/MPL/all_of.hpp"
-
 #include <tuple>
 #include <type_traits>
 
@@ -26,11 +24,11 @@ namespace Acts::detail {
 template <typename... extensions_t>
 struct Extendable {
   // clang-format off
-    static_assert(detail::all_of_v<std::is_default_constructible<extensions_t>::value...>,
+    static_assert((std::is_default_constructible<extensions_t>::value && ...),
                   "all extensions must be default constructible");
-    static_assert(detail::all_of_v<std::is_copy_constructible<extensions_t>::value...>,
+    static_assert((std::is_copy_constructible<extensions_t>::value && ...),
                   "all extensions must be copy constructible");
-    static_assert(detail::all_of_v<std::is_move_constructible<extensions_t>::value...>,
+    static_assert((std::is_move_constructible<extensions_t>::value && ...),
                   "all extensions must be move constructible");
   // clang-format on
 
diff --git a/Core/include/Acts/Utilities/detail/MPL/all_of.hpp b/Core/include/Acts/Utilities/detail/MPL/all_of.hpp
deleted file mode 100644
index 1553cb4f3f31..000000000000
--- a/Core/include/Acts/Utilities/detail/MPL/all_of.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#pragma once
-#include <type_traits>
-
-namespace Acts::detail {
-
-namespace {
-// clang-format off
-    template <bool... values>
-    struct all_of : std::true_type {};
-
-    template <bool... others>
-    struct all_of<false, others...> : public std::false_type {};
-
-    template <bool... others>
-    struct all_of<true, others...> : public all_of<others...> {};
-// clang-format on
-}  // end of anonymous namespace
-
-template <bool... values>
-constexpr bool all_of_v = all_of<values...>::value;
-}  // namespace Acts::detail
diff --git a/Core/include/Acts/Utilities/detail/MPL/any_of.hpp b/Core/include/Acts/Utilities/detail/MPL/any_of.hpp
deleted file mode 100644
index f56a669cfef6..000000000000
--- a/Core/include/Acts/Utilities/detail/MPL/any_of.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#pragma once
-#include <type_traits>
-
-namespace Acts::detail {
-
-namespace {
-// clang-format off
-    template <bool... values>
-    struct any_of : std::false_type {};
-
-    template <bool... others>
-    struct any_of<true, others...> : public std::true_type {};
-
-    template <bool... others>
-    struct any_of<false, others...> : public any_of<others...> {};
-// clang-format on
-}  // namespace
-
-template <bool... values>
-constexpr bool any_of_v = any_of<values...>::value;
-}  // namespace Acts::detail
diff --git a/Core/include/Acts/Utilities/detail/MPL/are_sorted.hpp b/Core/include/Acts/Utilities/detail/MPL/are_sorted.hpp
deleted file mode 100644
index e45cea4d3e56..000000000000
--- a/Core/include/Acts/Utilities/detail/MPL/are_sorted.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#pragma once
-namespace Acts::detail {
-/**
- * @brief check whether integral values are sorted
- *
- * @tparam ascending boolean flag to check for ascending order (@c true) or
- * descending order (@c false)
- * @tparam strict boolean flag whether strict ordering is required
- * @tparam T integral type of values whose order should be checked
- * @tparam values template parameter pack containing the list of values
- *
- * @test Unit tests are implemented \link
- * Acts::Test::BOOST_AUTO_TEST_CASE(are_sorted_helper_tests) here\endlink.
- *
- * @return `are_sorted<asc,strict,T,values...>::value` is @c true if the given
- * values are properly sorted,
- *         otherwise @c false
- */
-template <bool ascending, bool strict, typename T, T... values>
-struct are_sorted;
-
-/// @cond
-// one value is always sorted
-template <bool ascending, bool strict, typename T, T v>
-struct are_sorted<ascending, strict, T, v> {
-  enum { value = true };
-};
-
-// strict, ascending ordering
-template <typename T, T a, T b, T... N>
-struct are_sorted<true, true, T, a, b, N...> {
-  enum { value = ((a < b) && are_sorted<true, true, T, b, N...>::value) };
-};
-
-// weak, ascending ordering
-template <typename T, T a, T b, T... N>
-struct are_sorted<true, false, T, a, b, N...> {
-  enum { value = (a <= b && are_sorted<true, false, T, b, N...>::value) };
-};
-
-// strict, descending ordering
-template <typename T, T a, T b, T... N>
-struct are_sorted<false, true, T, a, b, N...> {
-  enum { value = (a > b && are_sorted<false, true, T, b, N...>::value) };
-};
-
-// weak, descending ordering
-template <typename T, T a, T b, T... N>
-struct are_sorted<false, false, T, a, b, N...> {
-  enum { value = (a >= b && are_sorted<false, false, T, b, N...>::value) };
-};
-/// @endcond
-}  // namespace Acts::detail
diff --git a/Core/include/Acts/Utilities/detail/MPL/are_within.hpp b/Core/include/Acts/Utilities/detail/MPL/are_within.hpp
deleted file mode 100644
index ab01b96d2591..000000000000
--- a/Core/include/Acts/Utilities/detail/MPL/are_within.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#pragma once
-namespace Acts::detail {
-/**
- * @brief check whether integral values are within a given range
- *
- * @tparam T integral type of values whose range should be checked
- * @tparam MIN lower accepted bound of values (inclusive)
- * @tparam MAX upper accepted bound of values (exclusive)
- * @tparam values template parameter pack containing the list of values
- *
- * @test Unit tests are implemented \link
- * Acts::Test::BOOST_AUTO_TEST_CASE(are_within_helper_tests) here\endlink.
- *
- * @return `are_within<T,MIN,MAX,values...>::value` is @c true if all given
- * values are within the
- *          interval [MIN,MAX), otherwise @c false
- */
-template <typename T, T MIN, T MAX, T... values>
-struct are_within;
-
-/// @cond
-// check last parameter
-template <typename T, T MIN, T MAX, T a>
-struct are_within<T, MIN, MAX, a> {
-  enum { value = (a >= MIN && a < MAX) };
-};
-
-// recursive check
-template <typename T, T MIN, T MAX, T a, T... others>
-struct are_within<T, MIN, MAX, a, others...> {
-  enum {
-    value =
-        ((a >= MIN) && (a < MAX) && are_within<T, MIN, MAX, others...>::value)
-  };
-};
-/// @endcond
-}  // namespace Acts::detail
diff --git a/Core/include/Acts/Utilities/detail/MPL/at_index.hpp b/Core/include/Acts/Utilities/detail/MPL/at_index.hpp
deleted file mode 100644
index c1e88111bb3a..000000000000
--- a/Core/include/Acts/Utilities/detail/MPL/at_index.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#pragma once
-namespace Acts::detail {
-/**
- * @brief return integral constant at position in template parameter pack
- *
- * @tparam T integral type of the values to be investigated
- * @tparam index position in the template parameter pack
- * @tparam values template parameter pack containing the list of values
- *
- * @return `at_index<T,index,values...>::type` yields the integral constant
- *         at the given position in `values` if 0 &le; `index` <
- *         sizeof...(values). Otherwise, a compile-time error is generated.
- */
-template <typename T, std::size_t index, T... values>
-struct at_index;
-
-/// @cond
-template <typename T, std::size_t index, T next, T... others>
-struct at_index<T, index, next, others...> {
-  static constexpr T value = at_index<T, index - 1, others...>::value;
-};
-
-template <typename T, T next, T... others>
-struct at_index<T, 0, next, others...> {
-  static constexpr T value = next;
-};
-/// @endcond
-}  // namespace Acts::detail
diff --git a/Core/include/Acts/Utilities/detail/MPL/has_duplicates.hpp b/Core/include/Acts/Utilities/detail/MPL/has_duplicates.hpp
deleted file mode 100644
index 41b4b80d876b..000000000000
--- a/Core/include/Acts/Utilities/detail/MPL/has_duplicates.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#pragma once
-namespace Acts::detail {
-
-namespace {
-template <typename... Args>
-struct has_duplicates;
-
-template <>
-struct has_duplicates<> {
-  static constexpr bool value = false;
-};
-
-template <typename last>
-struct has_duplicates<last> {
-  static constexpr bool value = false;
-};
-
-template <typename first, typename second, typename... others>
-struct has_duplicates<first, second, others...> {
- private:
-  static constexpr bool _first = has_duplicates<first, others...>::value;
-  static constexpr bool _second = has_duplicates<second, others...>::value;
-
- public:
-  static constexpr bool value = _first || _second;
-};
-
-template <typename first, typename... others>
-struct has_duplicates<first, first, others...> {
-  static constexpr bool value = true;
-};
-}  // namespace
-
-template <typename... Args>
-constexpr bool has_duplicates_v = has_duplicates<Args...>::value;
-}  // namespace Acts::detail
diff --git a/Core/include/Acts/Utilities/detail/MPL/type_collector.hpp b/Core/include/Acts/Utilities/detail/MPL/type_collector.hpp
deleted file mode 100644
index 3ff1f0ce994d..000000000000
--- a/Core/include/Acts/Utilities/detail/MPL/type_collector.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#pragma once
-
-#include <boost/hana/filter.hpp>
-#include <boost/hana/set.hpp>
-#include <boost/hana/type.hpp>
-
-namespace Acts::detail {
-
-namespace hana = boost::hana;
-
-/**
- * Struct which extracts the result type from an actor.
- * This is used as an argument to `type_collector`.
- */
-struct result_type_extractor {
-  // Checks whether the type even has a result type
-  static constexpr auto predicate = hana::is_valid(
-      [](auto t) -> hana::type<typename decltype(t)::type::result_type> {});
-  // meta function to extract the result type
-  template <typename T>
-  using extractor_impl = typename T::result_type;
-  // embed meta function in hana
-  static constexpr auto extractor = hana::template_<extractor_impl>;
-};
-
-/**
- * Struct which extracts the action type from an aborter.
- * This is used as an argument to `type_collector`.
- */
-struct action_type_extractor {
-  // Checks if aborter even has action type
-  static constexpr auto predicate = hana::is_valid(
-      [](auto t) -> hana::type<typename decltype(t)::type::action_type> {});
-  // meta function to extract the action type
-  template <typename T>
-  using extractor_impl = typename T::action_type;
-  // converted to hana
-  static constexpr auto extractor = hana::template_<extractor_impl>;
-};
-
-/**
- * The main type collector. This loops over the given tuple of actions or
- * aborters,
- * filters by predicate and uses extractor to construct a resulting output
- * set.
- */
-constexpr auto type_collector = [](auto t_, auto predicate, auto extractor) {
-  // filtered list using predicate
-  constexpr auto have_result =
-      hana::filter(t_, [&](auto t) { return predicate(t); });
-  // convert to set to remove duplicates, and transform to unpacked type
-  // using extractor.
-  constexpr auto result_types =
-      hana::to_set(hana::transform(have_result, extractor));
-  return result_types;
-};
-
-/**
- * Helper around type_collector which constructrs a hana tuple input from
- * variadic
- * template args, and pre-unpacks the predicate and extractor from the helper
- * type
- * @tparam helper Either result_type_extractor or action_type_extractor
- * @tparam items The items to filter / collect from.
- */
-template <typename helper, typename... items>
-constexpr auto type_collector_t = type_collector(
-    hana::tuple_t<items...>, helper::predicate, helper::extractor);
-
-/**
- * Meta function which returns a compile time bool
- * @tparam T the type to check
- */
-template <typename T>
-constexpr bool has_result_type_v =
-    decltype(result_type_extractor::predicate(hana::type_c<T>))::value;
-
-/**
- * Meta function which gets the result type from an action
- * @tparam T The type to extract from
- */
-template <typename T>
-using result_type_t = typename result_type_extractor::extractor_impl<T>;
-
-/**
- * Meta function which returns a compile time bool
- * @tparam T the type to check
- */
-template <typename T>
-constexpr bool has_action_type_v =
-    decltype(action_type_extractor::predicate(hana::type_c<T>))::value;
-
-/**
- * Meta function which gets the action for an aborter
- * @tparam T The type to extract from
- */
-template <typename T>
-using action_type_t = typename action_type_extractor::extractor_impl<T>;
-
-}  // namespace Acts::detail
diff --git a/Tests/UnitTests/Core/Utilities/CMakeLists.txt b/Tests/UnitTests/Core/Utilities/CMakeLists.txt
index 437b5533d3c3..53fa745bb753 100644
--- a/Tests/UnitTests/Core/Utilities/CMakeLists.txt
+++ b/Tests/UnitTests/Core/Utilities/CMakeLists.txt
@@ -25,7 +25,6 @@ add_unittest(Intersection IntersectionTests.cpp)
 add_unittest(KDTree KDTreeTests.cpp)
 add_unittest(Logger LoggerTests.cpp)
 add_unittest(MaterialMapUtils MaterialMapUtilsTests.cpp)
-add_unittest(MPL MPLTests.cpp)
 add_unittest(MultiIndex MultiIndexTests.cpp)
 add_unittest(Periodic PeriodicTests.cpp)
 add_unittest(Range1D Range1DTests.cpp)
diff --git a/Tests/UnitTests/Core/Utilities/MPLTests.cpp b/Tests/UnitTests/Core/Utilities/MPLTests.cpp
deleted file mode 100644
index 32c3e042a879..000000000000
--- a/Tests/UnitTests/Core/Utilities/MPLTests.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 2017-2018 CERN for the benefit of the Acts project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include <boost/test/unit_test.hpp>
-
-#include "Acts/Utilities/detail/MPL/all_of.hpp"
-#include "Acts/Utilities/detail/MPL/any_of.hpp"
-#include "Acts/Utilities/detail/MPL/are_sorted.hpp"
-#include "Acts/Utilities/detail/MPL/are_within.hpp"
-#include "Acts/Utilities/detail/MPL/at_index.hpp"
-#include "Acts/Utilities/detail/MPL/has_duplicates.hpp"
-#include "Acts/Utilities/detail/MPL/type_collector.hpp"
-
-#include <tuple>
-#include <type_traits>
-
-#include <boost/hana.hpp>
-#include <boost/hana/core/to.hpp>
-#include <boost/hana/equal.hpp>
-#include <boost/hana/ext/std/tuple.hpp>
-#include <boost/hana/integral_constant.hpp>
-#include <boost/hana/set.hpp>
-#include <boost/hana/transform.hpp>
-#include <boost/hana/tuple.hpp>
-#include <boost/hana/type.hpp>
-#include <boost/hana/union.hpp>
-
-namespace hana = boost::hana;
-
-namespace Acts::detail {
-template <bool ascending, bool strict, typename T, T... values>
-struct are_sorted;
-template <typename T, T MIN, T MAX, T... values>
-struct are_within;
-template <typename T, std::size_t index, T... values>
-struct at_index;
-}  // namespace Acts::detail
-
-namespace Acts::Test {
-
-BOOST_AUTO_TEST_CASE(all_of_test) {
-  using detail::all_of_v;
-
-  static_assert(!all_of_v<true, true, false>,
-                "all_of_v<true, true, false> failed");
-  static_assert(!all_of_v<false, true, true, false>,
-                "all_of_v<false, true, true, false> failed");
-  static_assert(all_of_v<true, true, true>,
-                "all_of_v<true, true, true> failed");
-  static_assert(all_of_v<true>, "all_of_v<true> failed");
-  static_assert(!all_of_v<false>, "all_of_v<false> failed");
-  static_assert(all_of_v<>, "all_of_v<> failed");
-}
-
-BOOST_AUTO_TEST_CASE(hana_set_union_test) {
-  // using first    = typename bm::set<float, int, char, bool>::type;
-  constexpr auto first = hana::make_set(hana::type_c<float>, hana::type_c<int>,
-                                        hana::type_c<char>, hana::type_c<bool>);
-  // using second   = typename bm::vector<long, int>::type;
-  constexpr auto second = hana::make_set(hana::type_c<long>, hana::type_c<int>);
-  constexpr auto found = hana::union_(first, second);
-  // using found    = typename detail::boost_set_merger_t<first, second>;
-  // using expected = typename bm::set<float, int, char, bool, long>::type;
-  constexpr auto expected =
-      hana::make_set(hana::type_c<float>, hana::type_c<int>, hana::type_c<char>,
-                     hana::type_c<bool>, hana::type_c<long>);
-
-  static_assert(found == expected, "union of hana::sets failed");
-}
-
-BOOST_AUTO_TEST_CASE(hana_set_to_tuple_test) {
-  constexpr auto a_set = hana::make_set(hana::type_c<float>, hana::type_c<int>,
-                                        hana::type_c<char>, hana::type_c<bool>);
-  constexpr auto h_tuple =
-      hana::make_tuple(hana::type_c<float>, hana::type_c<int>,
-                       hana::type_c<char>, hana::type_c<bool>);
-
-  static_assert(hana::to<hana::tuple_tag>(a_set) == h_tuple, "not equal");
-
-  // using std_tuple = decltype(hana::unpack(a_set,
-  // hana::template_<std::tuple>))::type; using expected = std::tuple<float,
-  // int, char>; static_assert(std::is_same<std_tuple, expected>::value,
-  // "using
-  // boost::mpl::set for variadic templates failed");
-}
-
-template <typename... args>
-struct variadic_struct {
-  using tuple = std::tuple<args...>;
-};
-
-BOOST_AUTO_TEST_CASE(unpack_boost_set_as_template_test) {
-  constexpr auto hana_set = hana::make_set(
-      hana::type_c<float>, hana::type_c<int>, hana::type_c<char>);
-  using found =
-      decltype(hana::unpack(hana_set, hana::template_<variadic_struct>))::type;
-
-  using expected = variadic_struct<float, int, char>;
-
-  static_assert(std::is_same<found, expected>::value,
-                "using boost::mpl::set for variadic templates failed");
-
-  static_assert(
-      std::is_same<expected::tuple, std::tuple<float, int, char>>::value,
-      "not equal");
-}
-
-namespace {
-struct traits1 {
-  using result_type = int;
-  using action_type = char;
-};
-
-template <bool>
-struct traits2;
-
-template <>
-struct traits2<false> {
-  using result_type = bool;
-  using action_type = float;
-};
-
-template <>
-struct traits2<true> {
-  using action_type = float;
-};
-}  // namespace
-
-template <typename... Args>
-struct tuple_helper {
-  using tuple = std::tuple<Args...>;
-};
-
-BOOST_AUTO_TEST_CASE(type_collector_test) {
-  // test some predicates
-  static_assert(detail::has_result_type_v<traits1>, "Did not find result type");
-  static_assert(detail::has_result_type_v<traits2<false>>,
-                "Did not find result type");
-  static_assert(!detail::has_result_type_v<traits2<true>>,
-                "Did find result type");
-
-  static_assert(detail::has_action_type_v<traits1>, "Did not find action type");
-  static_assert(detail::has_action_type_v<traits2<false>>,
-                "Did not find action type");
-  static_assert(detail::has_action_type_v<traits2<true>>,
-                "Did not find action type");
-
-  constexpr auto found_results =
-      detail::type_collector_t<detail::result_type_extractor, traits1,
-                               traits2<true>, traits2<false>>;
-  constexpr auto expected_results =
-      hana::make_set(hana::type_c<int>, hana::type_c<bool>);
-  static_assert(found_results == expected_results,
-                "Didn't find expected results");
-
-  // check unpack
-  using found_results_tuple = decltype(hana::unpack(
-      found_results, hana::template_<tuple_helper>))::type::tuple;
-  using expected_results_tuple = std::tuple<int, bool>;
-  static_assert(
-      std::is_same<found_results_tuple, expected_results_tuple>::value,
-      "Unpacked results tuple not correct");
-
-  constexpr auto found_actions =
-      detail::type_collector_t<detail::action_type_extractor, traits1,
-                               traits2<true>, traits2<false>>;
-  constexpr auto expected_actions =
-      hana::make_set(hana::type_c<char>, hana::type_c<float>);
-  static_assert(found_actions == expected_actions,
-                "Didn't find expected actions");
-
-  // check unpack
-  using found_actions_tuple = decltype(hana::unpack(
-      found_actions, hana::template_<tuple_helper>))::type::tuple;
-  using expected_actions_tuple = std::tuple<char, float>;
-  static_assert(
-      std::is_same<found_actions_tuple, expected_actions_tuple>::value,
-      "Unpacked actions tuple not correct");
-}
-
-BOOST_AUTO_TEST_CASE(has_duplicates_test) {
-  using detail::has_duplicates_v;
-  static_assert(has_duplicates_v<int, float, char, int>,
-                "has_duplicates_v failed");
-  static_assert(has_duplicates_v<int, int, char, float>,
-                "has_duplicates_v failed");
-  static_assert(has_duplicates_v<int, char, float, float>,
-                "has_duplicates_v failed");
-  static_assert(has_duplicates_v<int, char, char, float>,
-                "has_duplicates_v failed");
-  static_assert(!has_duplicates_v<int, bool, char, float>,
-                "has_duplicates_v failed");
-}
-
-BOOST_AUTO_TEST_CASE(any_of_test) {
-  using detail::any_of_v;
-
-  static_assert(any_of_v<true, true, false>,
-                "any_of_v<true, true, false> failed");
-  static_assert(any_of_v<false, true, true, false>,
-                "any_of_v<false, true, true, false> failed");
-  static_assert(any_of_v<true, true, true>,
-                "any_of_v<true, true, true> failed");
-  static_assert(!any_of_v<false, false>, "any_of_v<false, false> failed");
-  static_assert(any_of_v<true>, "any_of_v<true> failed");
-  static_assert(!any_of_v<false>, "any_of_v<false> failed");
-  static_assert(!any_of_v<>, "any_of_v<> failed");
-}
-
-/**
- * @brief Unit test for Acts::anonymous_namespace{ParameterSet.h}::are_sorted
- * helper
- *
- * The test checks for correct behavior in the following cases (always using
- * @c int
- * as value type):
- * -# test: ordered strictly ascending, input: ordered strictly ascending
- * -# test: ordered strictly ascending, input: unordered
- * -# test: ordered strictly ascending, input: ordered weakly ascending
- * -# test: ordered weakly ascending, input: ordered strictly ascending
- * -# test: ordered weakly ascending, input: unordered
- * -# test: ordered weakly ascending, input: ordered weakly ascending
- * -# test: ordered strictly descending, input: ordered strictly descending
- * -# test: ordered strictly descending, input: unordered
- * -# test: ordered strictly descending, input: ordered weakly descending
- * -# test: ordered weakly descending, input: ordered strictly descending
- * -# test: ordered weakly descending, input: unordered
- * -# test: ordered weakly descending, input: ordered weakly descending
- */
-BOOST_AUTO_TEST_CASE(are_sorted_helper_tests) {
-  using detail::are_sorted;
-  // strictly ascending
-  BOOST_CHECK((are_sorted<true, true, int, -1, 3, 4, 12>::value));
-  BOOST_CHECK((!are_sorted<true, true, int, -1, 13, 4>::value));
-  BOOST_CHECK((!are_sorted<true, true, int, -1, 4, 4, 7>::value));
-  // weakly ascending
-  BOOST_CHECK((are_sorted<true, false, int, -1, 3, 4, 12>::value));
-  BOOST_CHECK((!are_sorted<true, false, int, -1, 13, 4>::value));
-  BOOST_CHECK((are_sorted<true, false, int, -1, 4, 4, 7>::value));
-  // strictly descending
-  BOOST_CHECK((are_sorted<false, true, int, 1, -3, -4, -12>::value));
-  BOOST_CHECK((!are_sorted<false, true, int, 1, -13, -4>::value));
-  BOOST_CHECK((!are_sorted<false, true, int, 1, -4, -4>::value));
-  // weakly descending
-  BOOST_CHECK((are_sorted<false, false, int, 1, -3, -4, -12>::value));
-  BOOST_CHECK((!are_sorted<false, false, int, -1, -13, -4>::value));
-  BOOST_CHECK((are_sorted<false, false, int, -1, -4, -4, -7>::value));
-}
-
-/**
- * @brief Unit test for Acts::anonymous_namespace{ParameterSet.h}::are_within
- * helper
- *
- * The test checks for correct behavior in the following cases (always using
- * @c int
- * as value type):
- * -# all values within (MIN,MAX)
- * -# all values within [MIN,MAX)
- * -# one value < MIN
- * -# multiple values < MIN
- * -# one value > MAX
- * -# multiple values > Max
- * -# one value == MAX
- * -# contains values < MIN and >= MAX
- */
-BOOST_AUTO_TEST_CASE(are_within_helper_tests) {
-  using detail::are_within;
-  BOOST_CHECK((are_within<int, 0, 10, 1, 3, 7, 2>::value));
-  BOOST_CHECK((are_within<int, 0, 10, 1, 3, 0, 2>::value));
-  BOOST_CHECK((!are_within<int, 0, 10, -1, 3, 7, 2>::value));
-  BOOST_CHECK((!are_within<int, 0, 10, -1, 3, 7, -2>::value));
-  BOOST_CHECK((!are_within<int, 0, 10, 1, 3, 17, 2>::value));
-  BOOST_CHECK((!are_within<int, 0, 10, 1, 3, 17, 12>::value));
-  BOOST_CHECK((!are_within<int, 0, 10, 1, 10>::value));
-  BOOST_CHECK((!are_within<int, 0, 10, 1, -2, 10, 14>::value));
-}
-
-/**
- * @brief Unit test for Acts::details::at_index helper
- */
-BOOST_AUTO_TEST_CASE(at_index_helper_tests) {
-  using detail::at_index;
-  BOOST_CHECK_EQUAL((at_index<int, 0, 10, 1, 3, 7, 2>::value), 10);
-  BOOST_CHECK_EQUAL((at_index<int, 1, 10, 1, 3, 7, 2>::value), 1);
-  BOOST_CHECK_EQUAL((at_index<int, 2, 10, 1, 3, 7, 2>::value), 3);
-  BOOST_CHECK_EQUAL((at_index<int, 3, 10, 1, 3, 7, 2>::value), 7);
-  BOOST_CHECK_EQUAL((at_index<int, 4, 10, 1, 3, 7, 2>::value), 2);
-}
-
-}  // namespace Acts::Test