From 6b898a670e420cd9247ea6c705f09ea92f26ff66 Mon Sep 17 00:00:00 2001
From: Stephen Nicholas Swatman <stephen.nicholas.swatman@cern.ch>
Date: Wed, 11 Sep 2024 09:57:02 +0200
Subject: [PATCH] refactor: Remove MPL library

This commit removes the mostly unused MPL library. The few cases in
which it was being used could be easily refactored into uses of fold
expressions, which should allow better error messages.

Depends on #3573.
---
 .../include/Acts/Propagator/ActorConcepts.hpp |   5 +
 Core/include/Acts/Propagator/ActorList.hpp    |  32 +-
 .../detail/actor_list_implementation.hpp      |   5 +-
 Core/include/Acts/Utilities/TypeList.hpp      |  61 ++++
 .../Acts/Utilities/detail/Extendable.hpp      |   8 +-
 .../Acts/Utilities/detail/MPL/all_of.hpp      |  29 --
 .../Acts/Utilities/detail/MPL/any_of.hpp      |  29 --
 .../Acts/Utilities/detail/MPL/are_sorted.hpp  |  61 ----
 .../Acts/Utilities/detail/MPL/are_within.hpp  |  45 ---
 .../Acts/Utilities/detail/MPL/at_index.hpp    |  36 ---
 .../Utilities/detail/MPL/has_duplicates.hpp   |  44 ---
 .../Utilities/detail/MPL/type_collector.hpp   | 108 -------
 Tests/UnitTests/Core/Utilities/CMakeLists.txt |   1 -
 Tests/UnitTests/Core/Utilities/MPLTests.cpp   | 295 ------------------
 14 files changed, 87 insertions(+), 672 deletions(-)
 delete mode 100644 Core/include/Acts/Utilities/detail/MPL/all_of.hpp
 delete mode 100644 Core/include/Acts/Utilities/detail/MPL/any_of.hpp
 delete mode 100644 Core/include/Acts/Utilities/detail/MPL/are_sorted.hpp
 delete mode 100644 Core/include/Acts/Utilities/detail/MPL/are_within.hpp
 delete mode 100644 Core/include/Acts/Utilities/detail/MPL/at_index.hpp
 delete mode 100644 Core/include/Acts/Utilities/detail/MPL/has_duplicates.hpp
 delete mode 100644 Core/include/Acts/Utilities/detail/MPL/type_collector.hpp
 delete mode 100644 Tests/UnitTests/Core/Utilities/MPLTests.cpp

diff --git a/Core/include/Acts/Propagator/ActorConcepts.hpp b/Core/include/Acts/Propagator/ActorConcepts.hpp
index d83119135eab..559d0fee17f1 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 4050ed8a9079..68b4ba5a6551 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