From 90dde799ebcc73137e6f02996f4f88322b4f6c16 Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Wed, 28 Aug 2024 21:18:32 +0200
Subject: [PATCH 01/15] refactor!: Fuse `Actor` and `Aborter`

---
 .../Material/PropagatorMaterialAssigner.hpp   |  24 ++--
 Core/include/Acts/Propagator/AbortList.hpp    | 115 ------------------
 Core/include/Acts/Propagator/ActionList.hpp   |  94 --------------
 .../Propagator/DenseEnvironmentExtension.hpp  |   3 +-
 .../Acts/Propagator/MaterialInteractor.hpp    |  14 ++-
 .../Acts/Propagator/MultiStepperAborters.hpp  |  13 +-
 Core/include/Acts/Propagator/Propagator.hpp   |  62 +++++-----
 Core/include/Acts/Propagator/Propagator.ipp   |  92 +++++++-------
 .../Acts/Propagator/PropagatorOptions.hpp     |  40 +++---
 .../Acts/Propagator/RiddersPropagator.hpp     |  35 +++---
 .../Acts/Propagator/RiddersPropagator.ipp     |  21 ++--
 .../Acts/Propagator/StandardAborters.hpp      |  37 ++++--
 .../Acts/Propagator/SurfaceCollector.hpp      |  14 ++-
 .../Acts/Propagator/VolumeCollector.hpp       |  14 ++-
 .../Acts/Propagator/detail/SteppingLogger.hpp |  16 ++-
 .../detail/abort_list_implementation.hpp      | 108 ----------------
 .../detail/action_list_implementation.hpp     |  96 ---------------
 .../CombinatorialKalmanFilter.hpp             |  62 +++++-----
 .../Acts/TrackFitting/GaussianSumFitter.hpp   |  50 +++-----
 .../TrackFitting/GlobalChiSquareFitter.hpp    |  37 ++----
 .../Acts/TrackFitting/KalmanFitter.hpp        |  67 ++++------
 .../Acts/TrackFitting/detail/GsfActor.hpp     |  14 ++-
 Core/src/Material/SurfaceMaterialMapper.cpp   |  12 +-
 Core/src/Material/VolumeMaterialMapper.cpp    |  11 +-
 .../Propagation/PropagatorInterface.hpp       |  12 +-
 .../src/TrackFindingAlgorithm.cpp             |   6 +-
 .../include/ActsFatras/Kernel/Simulation.hpp  |  11 +-
 .../Kernel/detail/SimulationActor.hpp         |  35 ++----
 .../CommonHelpers/MeasurementsCreator.hpp     |  28 +++--
 .../IntegrationTests/NavigatorConsistency.cpp |  24 ++--
 .../PropagationBentTracks.cpp                 |   4 +-
 .../Material/VolumeMaterialMapperTests.cpp    |  19 ++-
 .../Navigation/DetectorNavigatorTests.cpp     |  37 +++---
 .../Core/Propagator/DirectNavigatorTests.cpp  |  18 ++-
 .../Core/Propagator/EigenStepperTests.cpp     |  57 +++++----
 .../Core/Propagator/ExtrapolatorTests.cpp     |  10 +-
 .../Propagator/KalmanExtrapolatorTests.cpp    |  26 ++--
 .../Core/Propagator/LoopProtectionTests.cpp   |   7 +-
 .../Propagator/MaterialCollectionTests.cpp    |  19 ++-
 .../Core/Propagator/PropagatorTests.cpp       |  39 +++---
 .../Core/Propagator/SympyStepperTests.cpp     |   3 +-
 .../Fatras/Kernel/SimulationActorTests.cpp    |  33 +++--
 docs/core/propagation.md                      |   2 +-
 43 files changed, 515 insertions(+), 926 deletions(-)
 delete mode 100644 Core/include/Acts/Propagator/AbortList.hpp
 delete mode 100644 Core/include/Acts/Propagator/ActionList.hpp
 delete mode 100644 Core/include/Acts/Propagator/detail/abort_list_implementation.hpp
 delete mode 100644 Core/include/Acts/Propagator/detail/action_list_implementation.hpp

diff --git a/Core/include/Acts/Material/PropagatorMaterialAssigner.hpp b/Core/include/Acts/Material/PropagatorMaterialAssigner.hpp
index 6cb85d74e75..ca54a7b08d7 100644
--- a/Core/include/Acts/Material/PropagatorMaterialAssigner.hpp
+++ b/Core/include/Acts/Material/PropagatorMaterialAssigner.hpp
@@ -12,8 +12,7 @@
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
 #include "Acts/Material/interface/IAssignmentFinder.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/Propagator.hpp"
 #include "Acts/Propagator/SurfaceCollector.hpp"
 #include "Acts/Surfaces/Surface.hpp"
@@ -62,9 +61,9 @@ struct InteractionVolumeCollector {
   /// @param [in,out] result is the mutable result object
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, result_type& result,
-                  const Logger& /*logger*/) const {
+  void act(propagator_state_t& state, const stepper_t& stepper,
+           const navigator_t& navigator, result_type& result,
+           const Logger& /*logger*/) const {
     // Retrieve the current volume
     auto currentVolume = navigator.currentVolume(state.navigation);
 
@@ -85,6 +84,14 @@ struct InteractionVolumeCollector {
       }
     }
   }
+
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+             const navigator_t& /*navigator*/, result_type& /*result*/,
+             const Logger& /*logger*/) const {
+    return false;
+  }
 };
 
 /// @class PropagatorMaterialAssigner
@@ -131,11 +138,10 @@ class PropagatorMaterialAssigner final : public IAssignmentFinder {
     // Prepare Action list and abort list
     using MaterialSurfaceCollector =
         SurfaceCollector<MaterialSurfaceIdentifier>;
-    using ActionList =
-        ActionList<MaterialSurfaceCollector, InteractionVolumeCollector>;
-    using AbortList = AbortList<EndOfWorldReached>;
+    using ActorList = ActorList<MaterialSurfaceCollector,
+                                InteractionVolumeCollector, EndOfWorldReached>;
     using PropagatorOptions =
-        typename propagator_t::template Options<ActionList, AbortList>;
+        typename propagator_t::template Options<ActorList>;
 
     PropagatorOptions options(gctx, mctx);
 
diff --git a/Core/include/Acts/Propagator/AbortList.hpp b/Core/include/Acts/Propagator/AbortList.hpp
deleted file mode 100644
index d18b1b991a3..00000000000
--- a/Core/include/Acts/Propagator/AbortList.hpp
+++ /dev/null
@@ -1,115 +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 "Acts/Propagator/detail/abort_list_implementation.hpp"
-#include "Acts/Utilities/detail/Extendable.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;
-
-namespace Acts {
-
-/// @brief AbortList object to be used in the propagation
-///
-/// The abort list is a list of structs or classes that
-/// is called at each propagation step and can trigger the abort
-/// of the current propagation.
-///
-/// It can (optionally) depend on a result of an Actor from
-/// the actor list.
-template <typename... aborters_t>
-struct AbortList : public detail::Extendable<aborters_t...> {
- private:
-  static_assert(!detail::has_duplicates_v<aborters_t...>,
-                "same aborter type specified several times");
-
-  using detail::Extendable<aborters_t...>::tuple;
-
- public:
-  /// @cond
-  // This uses the type collector
-  using result_type = typename decltype(hana::unpack(
-      detail::type_collector_t<detail::action_type_extractor, aborters_t...>,
-      hana::template_<AbortList>))::type;
-  /// @endcond
-
-  using detail::Extendable<aborters_t...>::get;
-
-  /// Default constructor
-  AbortList() = default;
-
-  /// Default copy constructor
-  ///
-  /// @param aborters The source action list
-  AbortList(const AbortList<aborters_t...>& aborters) = default;
-
-  /// Default move constructor
-  ///
-  /// @param aborters The source action list
-  AbortList(AbortList<aborters_t...>&& aborters) = default;
-
-  /// Default move assignment operator
-  ///
-  /// @param aborters The source action list
-  AbortList<aborters_t...>& operator=(
-      const AbortList<aborters_t...>& aborters) = default;
-
-  /// Default move assignment operator
-  ///
-  /// @param aborters The source action list
-  AbortList<aborters_t...>& operator=(AbortList<aborters_t...>&& aborters) =
-      default;
-
-  /// Constructor from tuple
-  ///
-  /// @param aborters Source extensions tuple
-  AbortList(const std::tuple<aborters_t...>& aborters)
-      : detail::Extendable<aborters_t...>(aborters) {}
-
-  /// Constructor from tuple move
-  ///
-  /// @param aborters Source extensions tuple
-  AbortList(std::tuple<aborters_t...>&& aborters)
-      : detail::Extendable<aborters_t...>(std::move(aborters)) {}
-
-  /// Append new entries and return a new condition
-  template <typename... appendices_t>
-  AbortList<aborters_t..., appendices_t...> append(appendices_t... aps) const {
-    auto catTuple =
-        std::tuple_cat(tuple(), std::tuple<appendices_t...>(aps...));
-    return AbortList<aborters_t..., appendices_t...>(std::move(catTuple));
-  }
-
-  /// This is the call signature for the abort list, it broadcasts the call
-  /// to the tuple() members of the list
-  ///
-  /// @tparam propagator_state_t is the state type of the propagator
-  /// @tparam stepper_t Type of the stepper
-  /// @tparam navigator_t Type of the navigator
-  ///
-  /// @param [in,out] state is the state object from the propagator
-  /// @param [in] stepper Stepper used for the propagation
-  /// @param [in] navigator Navigator used for the propagation
-  /// @param [in] args are the arguments to be passed to the aborters
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  bool operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, Args&&... args) const {
-    using impl = detail::abort_list_impl<aborters_t...>;
-    return impl::check(tuple(), state, stepper, navigator,
-                       std::forward<Args>(args)...);
-  }
-};
-
-}  // namespace Acts
diff --git a/Core/include/Acts/Propagator/ActionList.hpp b/Core/include/Acts/Propagator/ActionList.hpp
deleted file mode 100644
index 5ae6f85ff2e..00000000000
--- a/Core/include/Acts/Propagator/ActionList.hpp
+++ /dev/null
@@ -1,94 +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 "Acts/Propagator/detail/action_list_implementation.hpp"
-#include "Acts/Utilities/detail/Extendable.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;
-
-namespace Acts {
-
-/// @brief ActionList implementation to be used with the propagator
-///
-/// This is the ActionList struct that is used in the propagator
-/// to define a list of different actors_t that are each
-/// executed during the stepping procedure
-template <typename... actors_t>
-struct ActionList : public detail::Extendable<actors_t...> {
- private:
-  static_assert(!detail::has_duplicates_v<actors_t...>,
-                "same action type specified several times");
-
-  using detail::Extendable<actors_t...>::tuple;
-
- public:
-  /// @cond
-  // This uses the type collector and unpacks using the `R` meta function
-  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;
-  /// @endcond
-
-  using detail::Extendable<actors_t...>::get;
-
-  /// Default constructor
-  ActionList() = default;
-
-  /// Default copy constructor
-  ///
-  /// @param actors The source action list
-  ActionList(const ActionList<actors_t...>& actors) = default;
-
-  /// Default move constructor
-  ///
-  /// @param actors The source action list
-  ActionList(ActionList<actors_t...>&& actors) = default;
-
-  /// Default move assignment operator
-  ///
-  /// @param actors The source action list
-  ActionList<actors_t...>& operator=(const ActionList<actors_t...>& actors) =
-      default;
-
-  /// Default move assignment operator
-  ///
-  /// @param actors The source action list
-  ActionList<actors_t...>& operator=(ActionList<actors_t...>&& actors) =
-      default;
-
-  /// Call operator that is that broadcasts the call to the tuple()
-  /// members of the list
-  ///
-  /// @tparam propagator_state_t is the state type of the propagator
-  /// @tparam stepper_t Type of the stepper used for the propagation
-  /// @tparam navigator_t Type of the navigator used for the propagation
-  ///
-  /// @param [in,out] state This is the propagator state object
-  /// @param [in] stepper The stepper in use
-  /// @param [in] navigator The navigator in use
-  /// @param [in] args The arguments to be passed to the actions
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, Args&&... args) const {
-    using impl = detail::action_list_impl<actors_t...>;
-    impl::action(tuple(), state, stepper, navigator,
-                 std::forward<Args>(args)...);
-  }
-};
-
-}  // namespace Acts
diff --git a/Core/include/Acts/Propagator/DenseEnvironmentExtension.hpp b/Core/include/Acts/Propagator/DenseEnvironmentExtension.hpp
index eed51e1e847..cf76f0a1911 100644
--- a/Core/include/Acts/Propagator/DenseEnvironmentExtension.hpp
+++ b/Core/include/Acts/Propagator/DenseEnvironmentExtension.hpp
@@ -15,8 +15,7 @@
 #include "Acts/Definitions/PdgParticle.hpp"
 #include "Acts/Definitions/TrackParametrization.hpp"
 #include "Acts/Material/Interactions.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/Propagator.hpp"
 #include "Acts/Utilities/VectorHelpers.hpp"
 
diff --git a/Core/include/Acts/Propagator/MaterialInteractor.hpp b/Core/include/Acts/Propagator/MaterialInteractor.hpp
index 8b9ddfbb65d..5d1444dadab 100644
--- a/Core/include/Acts/Propagator/MaterialInteractor.hpp
+++ b/Core/include/Acts/Propagator/MaterialInteractor.hpp
@@ -56,9 +56,9 @@ struct MaterialInteractor {
   /// @param logger a logger instance
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, result_type& result,
-                  const Logger& logger) const {
+  void act(propagator_state_t& state, const stepper_t& stepper,
+           const navigator_t& navigator, result_type& result,
+           const Logger& logger) const {
     if (state.stage == PropagatorStage::postPropagation) {
       return;
     }
@@ -142,6 +142,14 @@ struct MaterialInteractor {
     }
   }
 
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+             const navigator_t& /*navigator*/, result_type& /*result*/,
+             const Logger& /*logger*/) const {
+    return false;
+  }
+
  private:
   /// @brief This function records the material effect
   ///
diff --git a/Core/include/Acts/Propagator/MultiStepperAborters.hpp b/Core/include/Acts/Propagator/MultiStepperAborters.hpp
index d811f1bc2f8..d9ff14ca562 100644
--- a/Core/include/Acts/Propagator/MultiStepperAborters.hpp
+++ b/Core/include/Acts/Propagator/MultiStepperAborters.hpp
@@ -27,6 +27,11 @@ struct MultiStepperSurfaceReached : public SurfaceReached {
   MultiStepperSurfaceReached() = default;
   MultiStepperSurfaceReached(double oLimit) : SurfaceReached(oLimit) {}
 
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  void act(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+           const navigator_t& /*navigator*/, const Logger& /*logger*/) const {}
+
   /// boolean operator for abort condition without using the result
   ///
   /// @tparam propagator_state_t Type of the propagator state
@@ -39,8 +44,8 @@ struct MultiStepperSurfaceReached : public SurfaceReached {
   /// @param logger a logger instance
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, const Logger& logger) const {
+  bool check(propagator_state_t& state, const stepper_t& stepper,
+             const navigator_t& navigator, const Logger& logger) const {
     if (surface == nullptr) {
       ACTS_VERBOSE(
           "MultiStepperSurfaceReached aborter | "
@@ -82,8 +87,8 @@ struct MultiStepperSurfaceReached : public SurfaceReached {
       auto singleState = cmp.singleState(state);
       const auto& singleStepper = cmp.singleStepper(stepper);
 
-      if (!SurfaceReached::operator()(singleState, singleStepper, navigator,
-                                      logger)) {
+      if (!SurfaceReached::check(singleState, singleStepper, navigator,
+                                 logger)) {
         reached = false;
       } else {
         cmp.status() = Acts::Intersection3D::Status::onSurface;
diff --git a/Core/include/Acts/Propagator/Propagator.hpp b/Core/include/Acts/Propagator/Propagator.hpp
index 8b42cc74cf9..854c251370b 100644
--- a/Core/include/Acts/Propagator/Propagator.hpp
+++ b/Core/include/Acts/Propagator/Propagator.hpp
@@ -20,8 +20,7 @@
 #include "Acts/EventData/TrackParametersConcept.hpp"
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/PropagatorOptions.hpp"
 #include "Acts/Propagator/PropagatorResult.hpp"
 #include "Acts/Propagator/PropagatorState.hpp"
@@ -148,10 +147,9 @@ class Propagator final
 
   using NavigatorOptions = typename navigator_t::Options;
 
-  template <typename action_list_t = ActionList<>,
-            typename aborter_list_t = AbortList<>>
-  using Options = PropagatorOptions<StepperOptions, NavigatorOptions,
-                                    action_list_t, aborter_list_t>;
+  template <typename actor_list_t = ActorList<>>
+  using Options =
+      PropagatorOptions<StepperOptions, NavigatorOptions, actor_list_t>;
 
   /// Constructor from implementation object
   ///
@@ -169,13 +167,13 @@ class Propagator final
   /// @brief Helper struct determining the state's type
   ///
   /// @tparam propagator_options_t Propagator options type
-  /// @tparam action_list_t List of propagation action types
+  /// @tparam actor_list_t List of propagation action types
   ///
   /// This helper struct provides type definitions to extract the correct
   /// propagation state type from a given TrackParameter type and an
-  /// ActionList.
+  /// ActorList.
   ///
-  template <typename propagator_options_t, typename action_list_t>
+  template <typename propagator_options_t, typename actor_list_t>
   struct state_type_helper {
     /// @brief Propagation state type for an arbitrary list of additional
     ///        propagation states
@@ -186,19 +184,19 @@ class Propagator final
     using this_state_type = State<propagator_options_t, args...>;
 
     /// @brief Propagation result type derived from a given action list
-    using type = typename action_list_t::template result_type<this_state_type>;
+    using type = typename actor_list_t::template result_type<this_state_type>;
   };
 
   /// @brief Helper struct determining the result's type
   ///
   /// @tparam parameters_t Type of final track parameters
-  /// @tparam action_list_t List of propagation action types
+  /// @tparam actor_list_t List of propagation action types
   ///
   /// This helper struct provides type definitions to extract the correct
   /// propagation result type from a given TrackParameter type and an
-  /// ActionList.
+  /// ActorList.
   ///
-  template <typename parameters_t, typename action_list_t>
+  template <typename parameters_t, typename actor_list_t>
   struct result_type_helper {
     /// @brief Propagation result type for an arbitrary list of additional
     ///        propagation results
@@ -209,28 +207,28 @@ class Propagator final
     using this_result_type = PropagatorResult<parameters_t, args...>;
 
     /// @brief Propagation result type derived from a given action list
-    using type = typename action_list_t::template result_type<this_result_type>;
+    using type = typename actor_list_t::template result_type<this_result_type>;
   };
 
  public:
   /// @brief Short-hand type definition for propagation state derived from
   ///        an action list
   ///
-  /// @tparam action_list_t List of propagation action types
+  /// @tparam actor_list_t List of propagation action types
   ///
-  template <typename propagator_options_t, typename action_list_t>
-  using action_list_t_state_t =
-      typename state_type_helper<propagator_options_t, action_list_t>::type;
+  template <typename propagator_options_t, typename actor_list_t>
+  using actor_list_t_state_t =
+      typename state_type_helper<propagator_options_t, actor_list_t>::type;
 
   /// @brief Short-hand type definition for propagation result derived from
   ///        an action list
   ///
   /// @tparam parameters_t Type of the final track parameters
-  /// @tparam action_list_t List of propagation action types
+  /// @tparam actor_list_t List of propagation action types
   ///
-  template <typename parameters_t, typename action_list_t>
-  using action_list_t_result_t =
-      typename result_type_helper<parameters_t, action_list_t>::type;
+  template <typename parameters_t, typename actor_list_t>
+  using actor_list_t_result_t =
+      typename result_type_helper<parameters_t, actor_list_t>::type;
 
   /// @brief Propagate track parameters
   ///
@@ -252,9 +250,8 @@ class Propagator final
   ///
   template <typename parameters_t, typename propagator_options_t,
             typename path_aborter_t = PathLimitReached>
-  Result<
-      action_list_t_result_t<StepperCurvilinearTrackParameters,
-                             typename propagator_options_t::action_list_type>>
+  Result<actor_list_t_result_t<StepperCurvilinearTrackParameters,
+                               typename propagator_options_t::actor_list_type>>
   propagate(const parameters_t& start, const propagator_options_t& options,
             bool makeCurvilinear = true) const;
 
@@ -279,9 +276,8 @@ class Propagator final
   template <typename parameters_t, typename propagator_options_t,
             typename target_aborter_t = SurfaceReached,
             typename path_aborter_t = PathLimitReached>
-  Result<
-      action_list_t_result_t<StepperBoundTrackParameters,
-                             typename propagator_options_t::action_list_type>>
+  Result<actor_list_t_result_t<StepperBoundTrackParameters,
+                               typename propagator_options_t::actor_list_type>>
   propagate(const parameters_t& start, const Surface& target,
             const propagator_options_t& options) const;
 
@@ -363,9 +359,8 @@ class Propagator final
   ///
   /// @return Propagation result
   template <typename propagator_state_t, typename propagator_options_t>
-  Result<
-      action_list_t_result_t<StepperCurvilinearTrackParameters,
-                             typename propagator_options_t::action_list_type>>
+  Result<actor_list_t_result_t<StepperCurvilinearTrackParameters,
+                               typename propagator_options_t::actor_list_type>>
   makeResult(propagator_state_t state, Result<void> result,
              const propagator_options_t& options, bool makeCurvilinear) const;
 
@@ -386,9 +381,8 @@ class Propagator final
   ///
   /// @return Propagation result
   template <typename propagator_state_t, typename propagator_options_t>
-  Result<
-      action_list_t_result_t<StepperBoundTrackParameters,
-                             typename propagator_options_t::action_list_type>>
+  Result<actor_list_t_result_t<StepperBoundTrackParameters,
+                               typename propagator_options_t::actor_list_type>>
   makeResult(propagator_state_t state, Result<void> result,
              const Surface& target, const propagator_options_t& options) const;
 
diff --git a/Core/include/Acts/Propagator/Propagator.ipp b/Core/include/Acts/Propagator/Propagator.ipp
index 2d33c29d24b..7578819e3ec 100644
--- a/Core/include/Acts/Propagator/Propagator.ipp
+++ b/Core/include/Acts/Propagator/Propagator.ipp
@@ -7,7 +7,7 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "Acts/EventData/TrackParametersConcept.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/ConstrainedStep.hpp"
 #include "Acts/Propagator/PropagatorError.hpp"
 #include "Acts/Propagator/StandardAborters.hpp"
@@ -27,13 +27,13 @@ template <typename S, typename N>
 template <typename propagator_state_t>
 auto Acts::Propagator<S, N>::propagate(propagator_state_t& state) const
     -> Result<void> {
-  // Pre-stepping call to the navigator and action list
+  // Pre-stepping call to the navigator and actor list
   ACTS_VERBOSE("Entering propagation.");
 
   state.stage = PropagatorStage::prePropagation;
 
-  // Pre-Stepping call to the action list
-  state.options.actionList(state, m_stepper, m_navigator, logger());
+  // Pre-Stepping call to the actor list
+  state.options.actorList.act(state, m_stepper, m_navigator, logger());
   // assume negative outcome, only set to true later if we actually have
   // a positive outcome.
 
@@ -41,7 +41,7 @@ auto Acts::Propagator<S, N>::propagate(propagator_state_t& state) const
   bool terminatedNormally = true;
 
   // Pre-Stepping: abort condition check
-  if (!state.options.abortList(state, m_stepper, m_navigator, logger())) {
+  if (!state.options.actorList.check(state, m_stepper, m_navigator, logger())) {
     // Stepping loop
     ACTS_VERBOSE("Starting stepping loop.");
 
@@ -69,11 +69,12 @@ auto Acts::Propagator<S, N>::propagate(propagator_state_t& state) const
       m_stepper.releaseStepSize(state.stepping, ConstrainedStep::actor);
       m_stepper.releaseStepSize(state.stepping, ConstrainedStep::aborter);
       // Post-stepping:
-      // navigator post step call - action list - aborter list
+      // navigator post step call - actor list act - actor list check
       state.stage = PropagatorStage::postStep;
       m_navigator.postStep(state, m_stepper);
-      state.options.actionList(state, m_stepper, m_navigator, logger());
-      if (state.options.abortList(state, m_stepper, m_navigator, logger())) {
+      state.options.actorList.act(state, m_stepper, m_navigator, logger());
+      if (state.options.actorList.check(state, m_stepper, m_navigator,
+                                        logger())) {
         terminatedNormally = true;
         break;
       }
@@ -94,9 +95,9 @@ auto Acts::Propagator<S, N>::propagate(propagator_state_t& state) const
     return PropagatorError::StepCountLimitReached;
   }
 
-  // Post-stepping call to the action list
+  // Post-stepping call to the actor list
   ACTS_VERBOSE("Stepping loop done.");
-  state.options.actionList(state, m_stepper, m_navigator, logger());
+  state.options.actorList.act(state, m_stepper, m_navigator, logger());
 
   // return progress flag here, decide on SUCCESS later
   return Result<void>::success();
@@ -108,9 +109,9 @@ template <typename parameters_t, typename propagator_options_t,
 auto Acts::Propagator<S, N>::propagate(const parameters_t& start,
                                        const propagator_options_t& options,
                                        bool makeCurvilinear) const
-    -> Result<action_list_t_result_t<
-        StepperCurvilinearTrackParameters,
-        typename propagator_options_t::action_list_type>> {
+    -> Result<
+        actor_list_t_result_t<StepperCurvilinearTrackParameters,
+                              typename propagator_options_t::actor_list_type>> {
   static_assert(
       std::is_copy_constructible<StepperCurvilinearTrackParameters>::value,
       "return track parameter type must be copy-constructible");
@@ -127,12 +128,12 @@ auto Acts::Propagator<S, N>::propagate(const parameters_t& start,
 template <typename S, typename N>
 template <typename parameters_t, typename propagator_options_t,
           typename target_aborter_t, typename path_aborter_t>
-auto Acts::Propagator<S, N>::propagate(const parameters_t& start,
-                                       const Surface& target,
-                                       const propagator_options_t& options)
-    const -> Result<action_list_t_result_t<
-              StepperBoundTrackParameters,
-              typename propagator_options_t::action_list_type>> {
+auto Acts::Propagator<S, N>::propagate(
+    const parameters_t& start, const Surface& target,
+    const propagator_options_t& options) const
+    -> Result<
+        actor_list_t_result_t<StepperBoundTrackParameters,
+                              typename propagator_options_t::actor_list_type>> {
   static_assert(BoundTrackParametersConcept<parameters_t>,
                 "Parameters do not fulfill bound parameters concept.");
 
@@ -163,16 +164,16 @@ auto Acts::Propagator<S, N>::makeState(
   path_aborter_t pathAborter;
   pathAborter.internalLimit = options.pathLimit;
 
-  auto abortList = options.abortList.append(pathAborter);
+  auto actorList = options.actorList.append(pathAborter);
 
   // The expanded options (including path limit)
-  auto eOptions = options.extend(abortList);
+  auto eOptions = options.extend(actorList);
   eOptions.navigation.startSurface = &start.referenceSurface();
   eOptions.navigation.targetSurface = nullptr;
   using OptionsType = decltype(eOptions);
   using StateType =
-      action_list_t_state_t<OptionsType,
-                            typename propagator_options_t::action_list_type>;
+      actor_list_t_state_t<OptionsType,
+                           typename propagator_options_t::actor_list_type>;
   // Initialize the internal propagator state
   StateType state{
       eOptions,
@@ -204,18 +205,18 @@ auto Acts::Propagator<S, N>::makeState(
   targetAborter.surface = &target;
   path_aborter_t pathAborter;
   pathAborter.internalLimit = options.pathLimit;
-  auto abortList = options.abortList.append(targetAborter, pathAborter);
+  auto actorList = options.actorList.append(targetAborter, pathAborter);
 
   // Create the extended options and declare their type
-  auto eOptions = options.extend(abortList);
+  auto eOptions = options.extend(actorList);
   eOptions.navigation.startSurface = &start.referenceSurface();
   eOptions.navigation.targetSurface = &target;
   using OptionsType = decltype(eOptions);
 
   // Initialize the internal propagator state
   using StateType =
-      action_list_t_state_t<OptionsType,
-                            typename propagator_options_t::action_list_type>;
+      actor_list_t_state_t<OptionsType,
+                           typename propagator_options_t::actor_list_type>;
   StateType state{
       eOptions,
       m_stepper.makeState(eOptions.geoContext, eOptions.magFieldContext, start,
@@ -238,19 +239,19 @@ auto Acts::Propagator<S, N>::makeResult(propagator_state_t state,
                                         Result<void> propagationResult,
                                         const propagator_options_t& /*options*/,
                                         bool makeCurvilinear) const
-    -> Result<action_list_t_result_t<
-        StepperCurvilinearTrackParameters,
-        typename propagator_options_t::action_list_type>> {
+    -> Result<
+        actor_list_t_result_t<StepperCurvilinearTrackParameters,
+                              typename propagator_options_t::actor_list_type>> {
   // Type of track parameters produced by the propagation
   using ReturnParameterType = StepperCurvilinearTrackParameters;
 
   static_assert(std::is_copy_constructible<ReturnParameterType>::value,
                 "return track parameter type must be copy-constructible");
 
-  // Type of the full propagation result, including output from actions
+  // Type of the full propagation result, including output from actors
   using ResultType =
-      action_list_t_result_t<ReturnParameterType,
-                             typename propagator_options_t::action_list_type>;
+      actor_list_t_result_t<ReturnParameterType,
+                            typename propagator_options_t::actor_list_type>;
 
   if (!propagationResult.ok()) {
     return propagationResult.error();
@@ -280,23 +281,22 @@ auto Acts::Propagator<S, N>::makeResult(propagator_state_t state,
 
 template <typename S, typename N>
 template <typename propagator_state_t, typename propagator_options_t>
-auto Acts::Propagator<S, N>::makeResult(propagator_state_t state,
-                                        Result<void> propagationResult,
-                                        const Surface& target,
-                                        const propagator_options_t& /*options*/)
-    const -> Result<action_list_t_result_t<
-              StepperBoundTrackParameters,
-              typename propagator_options_t::action_list_type>> {
+auto Acts::Propagator<S, N>::makeResult(
+    propagator_state_t state, Result<void> propagationResult,
+    const Surface& target, const propagator_options_t& /*options*/) const
+    -> Result<
+        actor_list_t_result_t<StepperBoundTrackParameters,
+                              typename propagator_options_t::actor_list_type>> {
   // Type of track parameters produced at the end of the propagation
   using ReturnParameterType = StepperBoundTrackParameters;
 
   static_assert(std::is_copy_constructible<ReturnParameterType>::value,
                 "return track parameter type must be copy-constructible");
 
-  // Type of the full propagation result, including output from actions
+  // Type of the full propagation result, including output from actors
   using ResultType =
-      action_list_t_result_t<ReturnParameterType,
-                             typename propagator_options_t::action_list_type>;
+      actor_list_t_result_t<ReturnParameterType,
+                            typename propagator_options_t::actor_list_type>;
 
   if (!propagationResult.ok()) {
     return propagationResult.error();
@@ -329,7 +329,7 @@ void Acts::Propagator<S, N>::initialize(propagator_state_t& state) const {
 
   // Apply the loop protection - it resets the internal path limit
   detail::setupLoopProtection(
-      state, m_stepper, state.options.abortList.template get<path_aborter_t>(),
+      state, m_stepper, state.options.actorList.template get<path_aborter_t>(),
       false, logger());
 }
 
@@ -348,8 +348,8 @@ Acts::Result<Acts::BoundTrackParameters>
 Acts::detail::BasePropagatorHelper<derived_t>::propagateToSurface(
     const BoundTrackParameters& start, const Surface& target,
     const Options& options) const {
-  using ResultType = Result<typename derived_t::template action_list_t_result_t<
-      BoundTrackParameters, ActionList<>>>;
+  using ResultType = Result<typename derived_t::template actor_list_t_result_t<
+      BoundTrackParameters, ActorList<>>>;
   using DerivedOptions = typename derived_t::template Options<>;
 
   DerivedOptions derivedOptions(options);
diff --git a/Core/include/Acts/Propagator/PropagatorOptions.hpp b/Core/include/Acts/Propagator/PropagatorOptions.hpp
index 46916aece54..2aac175476f 100644
--- a/Core/include/Acts/Propagator/PropagatorOptions.hpp
+++ b/Core/include/Acts/Propagator/PropagatorOptions.hpp
@@ -12,8 +12,7 @@
 #include "Acts/Definitions/Tolerance.hpp"
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/NavigatorOptions.hpp"
 #include "Acts/Propagator/StepperOptions.hpp"
 
@@ -67,20 +66,15 @@ struct PropagatorPlainOptions : public detail::PurePropagatorPlainOptions {
 
 /// @brief Options for propagate() call
 ///
-/// @tparam action_list_t List of action types called after each
+/// @tparam actor_list_t List of action types called after each
 ///    propagation step with the current propagation and stepper state
 ///
-/// @tparam aborter_list_t List of abort conditions tested after each
-///    propagation step using the current propagation and stepper state
-///
 template <typename stepper_options_t, typename navigator_options_t,
-          typename action_list_t = ActionList<>,
-          typename aborter_list_t = AbortList<>>
+          typename actor_list_t = ActorList<>>
 struct PropagatorOptions : public detail::PurePropagatorPlainOptions {
   using stepper_options_type = stepper_options_t;
   using navigator_options_type = navigator_options_t;
-  using action_list_type = action_list_t;
-  using aborter_list_type = aborter_list_t;
+  using actor_list_type = actor_list_t;
 
   /// PropagatorOptions with context
   PropagatorOptions(const GeometryContext& gctx,
@@ -104,17 +98,17 @@ struct PropagatorOptions : public detail::PurePropagatorPlainOptions {
     return pOptions;
   }
 
-  /// @brief Expand the Options with extended aborters
+  /// @brief Expand the options with extended actors
   ///
-  /// @tparam extended_aborter_list_t Type of the new aborter list
+  /// @tparam extended_actor_list_t Type of the new actor list
   ///
-  /// @param aborters The new aborter list to be used (internally)
-  template <typename extended_aborter_list_t>
-  PropagatorOptions<stepper_options_t, navigator_options_t, action_list_t,
-                    extended_aborter_list_t>
-  extend(extended_aborter_list_t aborters) const {
-    PropagatorOptions<stepper_options_t, navigator_options_t, action_list_t,
-                      extended_aborter_list_t>
+  /// @param extendedActorList The new actor list to be used (internally)
+  template <typename extended_actor_list_t>
+  PropagatorOptions<stepper_options_t, navigator_options_t,
+                    extended_actor_list_t>
+  extend(extended_actor_list_t extendedActorList) const {
+    PropagatorOptions<stepper_options_t, navigator_options_t,
+                      extended_actor_list_t>
         eoptions(geoContext, magFieldContext);
 
     // Copy the base options
@@ -126,8 +120,7 @@ struct PropagatorOptions : public detail::PurePropagatorPlainOptions {
     eoptions.navigation = navigation;
 
     // Action / Abort list
-    eoptions.actionList = actionList;
-    eoptions.abortList = aborters;
+    eoptions.actorList = extendedActorList;
 
     // And return the options
     return eoptions;
@@ -157,10 +150,7 @@ struct PropagatorOptions : public detail::PurePropagatorPlainOptions {
   navigator_options_t navigation;
 
   /// List of actions
-  action_list_t actionList;
-
-  /// List of abort conditions
-  aborter_list_t abortList;
+  actor_list_t actorList;
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Propagator/RiddersPropagator.hpp b/Core/include/Acts/Propagator/RiddersPropagator.hpp
index 9f265f153ae..aecb1fdfb5f 100644
--- a/Core/include/Acts/Propagator/RiddersPropagator.hpp
+++ b/Core/include/Acts/Propagator/RiddersPropagator.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2017-2019 CERN for the benefit of the Acts project
+// Copyright (C) 2017-2024 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
@@ -36,20 +36,20 @@ class RiddersPropagator {
   using Covariance = BoundSquareMatrix;
 
   ///
-  /// @note The result_type_helper struct and the action_list_t_result_t are
+  /// @note The result_type_helper struct and the actor_list_t_result_t are
   /// here to allow a look'n'feel of this class like the Propagator itself
   ///
 
   /// @brief Helper struct determining the result's type
   ///
   /// @tparam parameters_t Type of final track parameters
-  /// @tparam action_list_t    List of propagation action types
+  /// @tparam actor_list_t    List of propagation action types
   ///
   /// This helper struct provides type definitions to extract the correct
   /// propagation result type from a given TrackParameter type and an
-  /// ActionList.
+  /// ActorList.
   ///
-  template <typename parameters_t, typename action_list_t>
+  template <typename parameters_t, typename actor_list_t>
   struct result_type_helper {
     /// @brief Propagation result type for an arbitrary list of additional
     ///        propagation results
@@ -60,18 +60,18 @@ class RiddersPropagator {
     using this_result_type = PropagatorResult<parameters_t, args...>;
 
     /// @brief Propagation result type derived from a given action list
-    using type = typename action_list_t::template result_type<this_result_type>;
+    using type = typename actor_list_t::template result_type<this_result_type>;
   };
 
   /// @brief Short-hand type definition for propagation result derived from
   ///        an action list
   ///
   /// @tparam parameters_t Type of the final track parameters
-  /// @tparam action_list_t List of propagation action types
+  /// @tparam actor_list_t List of propagation action types
   ///
-  template <typename parameters_t, typename action_list_t>
-  using action_list_t_result_t =
-      typename result_type_helper<parameters_t, action_list_t>::type;
+  template <typename parameters_t, typename actor_list_t>
+  using actor_list_t_result_t =
+      typename result_type_helper<parameters_t, actor_list_t>::type;
 
  public:
   struct Config {
@@ -81,10 +81,8 @@ class RiddersPropagator {
     std::vector<double> deviationsDisc = {-3e-5, -1e-5, 1e-5, 3e-5};
   };
 
-  template <typename action_list_t = ActionList<>,
-            typename aborter_list_t = AbortList<>>
-  using Options =
-      typename propagator_t::template Options<action_list_t, aborter_list_t>;
+  template <typename actor_list_t = ActorList<>>
+  using Options = typename propagator_t::template Options<actor_list_t>;
 
   /// @brief Constructor using a propagator
   ///
@@ -117,9 +115,8 @@ class RiddersPropagator {
   ///
   /// @return Result of the propagation
   template <typename parameters_t, typename propagator_options_t>
-  Result<
-      action_list_t_result_t<CurvilinearTrackParameters,
-                             typename propagator_options_t::action_list_type>>
+  Result<actor_list_t_result_t<CurvilinearTrackParameters,
+                               typename propagator_options_t::actor_list_type>>
   propagate(const parameters_t& start,
             const propagator_options_t& options) const;
 
@@ -136,8 +133,8 @@ class RiddersPropagator {
   /// @note If the target surface is a disc, the resulting covariance may be
   /// inconsistent. In this case a zero matrix is returned.
   template <typename parameters_t, typename propagator_options_t>
-  Result<action_list_t_result_t<
-      BoundTrackParameters, typename propagator_options_t::action_list_type>>
+  Result<actor_list_t_result_t<BoundTrackParameters,
+                               typename propagator_options_t::actor_list_type>>
   propagate(const parameters_t& start, const Surface& target,
             const propagator_options_t& options) const;
 
diff --git a/Core/include/Acts/Propagator/RiddersPropagator.ipp b/Core/include/Acts/Propagator/RiddersPropagator.ipp
index cc8e1114d93..653107e0fc1 100644
--- a/Core/include/Acts/Propagator/RiddersPropagator.ipp
+++ b/Core/include/Acts/Propagator/RiddersPropagator.ipp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2017-2023 CERN for the benefit of the Acts project
+// Copyright (C) 2017-2024 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
@@ -12,12 +12,12 @@ template <typename propagator_t>
 template <typename parameters_t, typename propagator_options_t>
 auto Acts::RiddersPropagator<propagator_t>::propagate(
     const parameters_t& start, const propagator_options_t& options) const
-    -> Result<action_list_t_result_t<
-        CurvilinearTrackParameters,
-        typename propagator_options_t::action_list_type>> {
+    -> Result<
+        actor_list_t_result_t<CurvilinearTrackParameters,
+                              typename propagator_options_t::actor_list_type>> {
   using ThisResult = Result<
-      action_list_t_result_t<CurvilinearTrackParameters,
-                             typename propagator_options_t::action_list_type>>;
+      actor_list_t_result_t<CurvilinearTrackParameters,
+                            typename propagator_options_t::actor_list_type>>;
 
   // Remove the covariance from our start parameters in order to skip jacobian
   // transport for the nominal propagation
@@ -55,11 +55,10 @@ template <typename parameters_t, typename propagator_options_t>
 auto Acts::RiddersPropagator<propagator_t>::propagate(
     const parameters_t& start, const Surface& target,
     const propagator_options_t& options) const
-    -> Result<action_list_t_result_t<
-        BoundTrackParameters,
-        typename propagator_options_t::action_list_type>> {
-  using ThisResult = Result<action_list_t_result_t<
-      BoundTrackParameters, typename propagator_options_t::action_list_type>>;
+    -> Result<actor_list_t_result_t<
+        BoundTrackParameters, typename propagator_options_t::actor_list_type>> {
+  using ThisResult = Result<actor_list_t_result_t<
+      BoundTrackParameters, typename propagator_options_t::actor_list_type>>;
 
   // Remove the covariance from our start parameters in order to skip jacobian
   // transport for the nominal propagation
diff --git a/Core/include/Acts/Propagator/StandardAborters.hpp b/Core/include/Acts/Propagator/StandardAborters.hpp
index 84ac3a427cf..2db05e76532 100644
--- a/Core/include/Acts/Propagator/StandardAborters.hpp
+++ b/Core/include/Acts/Propagator/StandardAborters.hpp
@@ -29,6 +29,11 @@ struct PathLimitReached {
   /// Boolean switch for Loop protection
   double internalLimit = std::numeric_limits<double>::max();
 
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  void act(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+           const navigator_t& /*navigator*/, const Logger& /*logger*/) const {}
+
   /// boolean operator for abort condition without using the result
   ///
   /// @tparam propagator_state_t Type of the propagator state
@@ -41,8 +46,8 @@ struct PathLimitReached {
   /// @param logger a logger instance
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, const Logger& logger) const {
+  bool check(propagator_state_t& state, const stepper_t& stepper,
+             const navigator_t& navigator, const Logger& logger) const {
     (void)navigator;
 
     // Check if the maximum allowed step size has to be updated
@@ -79,6 +84,11 @@ struct SurfaceReached {
   SurfaceReached() = default;
   SurfaceReached(double nLimit) : nearLimit(nLimit) {}
 
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  void act(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+           const navigator_t& /*navigator*/, const Logger& /*logger*/) const {}
+
   /// boolean operator for abort condition without using the result
   ///
   /// @tparam propagator_state_t Type of the propagator state
@@ -91,8 +101,8 @@ struct SurfaceReached {
   /// @param logger a logger instance
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, const Logger& logger) const {
+  bool check(propagator_state_t& state, const stepper_t& stepper,
+             const navigator_t& navigator, const Logger& logger) const {
     if (surface == nullptr) {
       ACTS_VERBOSE("SurfaceReached aborter | Target surface not set.");
       return false;
@@ -166,6 +176,11 @@ struct ForcedSurfaceReached : SurfaceReached {
 struct EndOfWorldReached {
   EndOfWorldReached() = default;
 
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  void act(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+           const navigator_t& /*navigator*/, const Logger& /*logger*/) const {}
+
   /// boolean operator for abort condition without using the result
   ///
   /// @tparam propagator_state_t Type of the propagator state
@@ -175,9 +190,8 @@ struct EndOfWorldReached {
   /// @param [in] navigator The navigator object
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool operator()(propagator_state_t& state, const stepper_t& /*stepper*/,
-                  const navigator_t& navigator,
-                  const Logger& /*logger*/) const {
+  bool check(propagator_state_t& state, const stepper_t& /*stepper*/,
+             const navigator_t& navigator, const Logger& /*logger*/) const {
     bool endOfWorld = navigator.endOfWorldReached(state.navigation);
     return endOfWorld;
   }
@@ -187,8 +201,13 @@ struct EndOfWorldReached {
 struct AnySurfaceReached {
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, const Logger& logger) const {
+  void act(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+           const navigator_t& /*navigator*/, const Logger& /*logger*/) const {}
+
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool check(propagator_state_t& state, const stepper_t& stepper,
+             const navigator_t& navigator, const Logger& logger) const {
     (void)stepper;
     (void)logger;
 
diff --git a/Core/include/Acts/Propagator/SurfaceCollector.hpp b/Core/include/Acts/Propagator/SurfaceCollector.hpp
index 4f996019233..14c22777e10 100644
--- a/Core/include/Acts/Propagator/SurfaceCollector.hpp
+++ b/Core/include/Acts/Propagator/SurfaceCollector.hpp
@@ -92,9 +92,9 @@ struct SurfaceCollector {
   /// @param logger a logger instance
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, result_type& result,
-                  const Logger& logger) const {
+  void act(propagator_state_t& state, const stepper_t& stepper,
+           const navigator_t& navigator, result_type& result,
+           const Logger& logger) const {
     if (state.stage == PropagatorStage::postPropagation) {
       return;
     }
@@ -114,6 +114,14 @@ struct SurfaceCollector {
       ACTS_VERBOSE("Collect surface  " << currentSurface->geometryId());
     }
   }
+
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+             const navigator_t& /*navigator*/, result_type& /*result*/,
+             const Logger& /*logger*/) const {
+    return false;
+  }
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Propagator/VolumeCollector.hpp b/Core/include/Acts/Propagator/VolumeCollector.hpp
index de503b8d58d..34a1a96b4be 100644
--- a/Core/include/Acts/Propagator/VolumeCollector.hpp
+++ b/Core/include/Acts/Propagator/VolumeCollector.hpp
@@ -91,9 +91,9 @@ struct VolumeCollector {
   /// @param logger the logger object
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, result_type& result,
-                  const Logger& logger) const {
+  void act(propagator_state_t& state, const stepper_t& stepper,
+           const navigator_t& navigator, result_type& result,
+           const Logger& logger) const {
     auto currentVolume = navigator.currentVolume(state.navigation);
 
     // The current volume has been assigned by the navigator
@@ -119,6 +119,14 @@ struct VolumeCollector {
       }
     }
   }
+
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+             const navigator_t& /*navigator*/, result_type& /*result*/,
+             const Logger& /*logger*/) const {
+    return false;
+  }
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Propagator/detail/SteppingLogger.hpp b/Core/include/Acts/Propagator/detail/SteppingLogger.hpp
index 42e909f4788..3bc6cb49d4f 100644
--- a/Core/include/Acts/Propagator/detail/SteppingLogger.hpp
+++ b/Core/include/Acts/Propagator/detail/SteppingLogger.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
+// Copyright (C) 2016-2024 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
@@ -68,9 +68,9 @@ struct SteppingLogger {
   /// @param [in,out] result is the mutable result object
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, result_type& result,
-                  const Logger& /*logger*/) const {
+  void act(propagator_state_t& state, const stepper_t& stepper,
+           const navigator_t& navigator, result_type& result,
+           const Logger& /*logger*/) const {
     // Don't log if you have reached the target or are sterile
     if (sterile || state.stage == PropagatorStage::postPropagation) {
       return;
@@ -94,6 +94,14 @@ struct SteppingLogger {
     }
     result.steps.push_back(std::move(step));
   }
+
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+             const navigator_t& /*navigator*/, result_type& /*result*/,
+             const Logger& /*logger*/) const {
+    return false;
+  }
 };
 
 }  // namespace detail
diff --git a/Core/include/Acts/Propagator/detail/abort_list_implementation.hpp b/Core/include/Acts/Propagator/detail/abort_list_implementation.hpp
deleted file mode 100644
index 5c4a7d5b959..00000000000
--- a/Core/include/Acts/Propagator/detail/abort_list_implementation.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 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 "Acts/Utilities/detail/MPL/type_collector.hpp"
-
-#include <utility>
-
-namespace Acts::detail {
-
-namespace {
-
-/// This is the caller used if the aborter uses the result and that result type
-/// exists
-template <bool has_result = true>
-struct abort_checker {
-  template <typename aborter_t, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static bool check(const aborter_t& aborter, propagator_state_t& state,
-                    const stepper_t& stepper, const navigator_t& navigator,
-                    Args&&... args) {
-    using action_type = action_type_t<aborter_t>;
-    using result_type = result_type_t<action_type>;
-
-    return aborter(state, stepper, navigator, state.template get<result_type>(),
-                   std::forward<Args>(args)...);
-  }
-};
-
-/// This is the caller used if the aborter only uses the cache it has no access
-/// to the result
-template <>
-struct abort_checker<false> {
-  template <typename aborter_t, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static bool check(const aborter_t& aborter, propagator_state_t& state,
-                    const stepper_t& stepper, const navigator_t& navigator,
-                    Args&&... args) {
-    return aborter(state, stepper, navigator, std::forward<Args>(args)...);
-  }
-};
-}  // end of anonymous namespace
-
-template <typename... conditions>
-struct abort_list_impl;
-
-/// This is the check call on the a list of conditions it calls the apparent
-/// condition and broadcasts the call to the remaining ones
-template <typename first, typename... others>
-struct abort_list_impl<first, others...> {
-  template <typename T, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static bool check(const T& aborters_tuple, propagator_state_t& state,
-                    const stepper_t& stepper, const navigator_t& navigator,
-                    Args&&... args) {
-    // get the right helper for calling the abort condition
-    constexpr bool has_result = has_action_type_v<first>;
-
-    // get the cache abort condition
-    const auto& this_aborter = std::get<first>(aborters_tuple);
-    // - check abort conditions recursively
-    // - make use of short-circuit evaluation
-    // -> skip remaining conditions if this abort condition evaluates to true
-
-    bool abort = abort_checker<has_result>::check(this_aborter, state, stepper,
-                                                  navigator, args...) ||
-                 abort_list_impl<others...>::check(aborters_tuple, state,
-                                                   stepper, navigator, args...);
-
-    return abort;
-  }
-};
-
-/// This is the check call on the a last of all conditions
-template <typename last>
-struct abort_list_impl<last> {
-  template <typename T, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static bool check(const T& aborters_tuple, propagator_state_t& state,
-                    const stepper_t& stepper, const navigator_t& navigator,
-                    Args&&... args) {
-    // get the right helper for calling the abort condition
-    constexpr bool has_result = has_action_type_v<last>;
-    const auto& this_aborter = std::get<last>(aborters_tuple);
-    return abort_checker<has_result>::check(
-        this_aborter, state, stepper, navigator, std::forward<Args>(args)...);
-  }
-};
-
-/// This is the empty call list - never abort
-template <>
-struct abort_list_impl<> {
-  template <typename T, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static bool check(const T& /*aborter_tuple*/, propagator_state_t& /*state*/,
-                    const stepper_t& /*stepper*/,
-                    const navigator_t& /*navigator*/, Args&&... /*args*/) {
-    return false;
-  }
-};
-
-}  // namespace Acts::detail
diff --git a/Core/include/Acts/Propagator/detail/action_list_implementation.hpp b/Core/include/Acts/Propagator/detail/action_list_implementation.hpp
deleted file mode 100644
index c58a62191cf..00000000000
--- a/Core/include/Acts/Propagator/detail/action_list_implementation.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 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 "Acts/Utilities/detail/MPL/type_collector.hpp"
-
-#include <utility>
-
-namespace Acts::detail {
-
-namespace {
-
-/// The action caller struct, it's called with the the right result object,
-/// which is taken out from the result tuple
-template <bool has_result = true>
-struct action_caller {
-  template <typename actor_t, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static void action(const actor_t& act, propagator_state_t& state,
-                     const stepper_t& stepper, const navigator_t& navigator,
-                     Args&&... args) {
-    act(state, stepper, navigator,
-        state.template get<detail::result_type_t<actor_t>>(),
-        std::forward<Args>(args)...);
-  }
-};
-
-/// The action caller struct, without result object
-template <>
-struct action_caller<false> {
-  template <typename actor_t, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static void action(const actor_t& act, propagator_state_t& state,
-                     const stepper_t& stepper, const navigator_t& navigator,
-                     Args&&... args) {
-    act(state, stepper, navigator, std::forward<Args>(args)...);
-  }
-};
-}  // end of anonymous namespace
-
-/// The dummy list call implementation
-template <typename... actors>
-struct action_list_impl;
-
-/// The action list call implementation
-/// - it calls 'action' on the current entry of the tuple
-/// - then broadcasts the action call to the remaining tuple
-template <typename first, typename... others>
-struct action_list_impl<first, others...> {
-  template <typename T, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static void action(const T& actors_tuple, propagator_state_t& state,
-                     const stepper_t& stepper, const navigator_t& navigator,
-                     Args&&... args) {
-    constexpr bool has_result = has_result_type_v<first>;
-    const auto& this_actor = std::get<first>(actors_tuple);
-    action_caller<has_result>::action(this_actor, state, stepper, navigator,
-                                      args...);
-    action_list_impl<others...>::action(actors_tuple, state, stepper, navigator,
-                                        args...);
-  }
-};
-
-/// The action list call implementation
-/// - it calls 'action' on the last entry of the tuple
-template <typename last>
-struct action_list_impl<last> {
-  template <typename T, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static void action(const T& actors_tuple, propagator_state_t& state,
-                     const stepper_t& stepper, const navigator_t& navigator,
-                     Args&&... args) {
-    constexpr bool has_result = has_result_type_v<last>;
-    const auto& this_actor = std::get<last>(actors_tuple);
-    action_caller<has_result>::action(this_actor, state, stepper, navigator,
-                                      std::forward<Args>(args)...);
-  }
-};
-
-/// The empty action list call implementation
-template <>
-struct action_list_impl<> {
-  template <typename T, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static void action(const T& /*actors_tuple*/, propagator_state_t& /*state*/,
-                     const stepper_t& /*stepper*/,
-                     const navigator_t& /*navigator*/, Args&&... /*args*/) {}
-};
-
-}  // namespace Acts::detail
diff --git a/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp b/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp
index 7156160a606..e4820ff5118 100644
--- a/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp
+++ b/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp
@@ -24,8 +24,7 @@
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
 #include "Acts/Material/MaterialSlab.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/ConstrainedStep.hpp"
 #include "Acts/Propagator/Propagator.hpp"
 #include "Acts/Propagator/StandardAborters.hpp"
@@ -538,9 +537,9 @@ class CombinatorialKalmanFilter {
     /// @param result is the mutable result state object
     template <typename propagator_state_t, typename stepper_t,
               typename navigator_t>
-    void operator()(propagator_state_t& state, const stepper_t& stepper,
-                    const navigator_t& navigator, result_type& result,
-                    const Logger& /*logger*/) const {
+    void act(propagator_state_t& state, const stepper_t& stepper,
+             const navigator_t& navigator, result_type& result,
+             const Logger& /*logger*/) const {
       assert(result.trackStates && "No MultiTrajectory set");
 
       if (result.finished) {
@@ -585,11 +584,11 @@ class CombinatorialKalmanFilter {
       }
 
       const bool isEndOfWorldReached =
-          endOfWorldReached(state, stepper, navigator, logger());
+          endOfWorldReached.check(state, stepper, navigator, logger());
       const bool isPathLimitReached =
-          result.pathLimitReached(state, stepper, navigator, logger());
+          result.pathLimitReached.check(state, stepper, navigator, logger());
       const bool isTargetReached =
-          targetReached(state, stepper, navigator, logger());
+          targetReached.check(state, stepper, navigator, logger());
       const bool allBranchesStopped = result.activeBranches.empty();
       if (isEndOfWorldReached || isPathLimitReached || isTargetReached ||
           allBranchesStopped) {
@@ -642,6 +641,14 @@ class CombinatorialKalmanFilter {
       }
     }
 
+    template <typename propagator_state_t, typename stepper_t,
+              typename navigator_t>
+    bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+               const navigator_t& /*navigator*/, const result_type& result,
+               const Logger& /*logger*/) const {
+      return !result.lastError.ok() || result.finished;
+    }
+
     /// @brief CombinatorialKalmanFilter actor operation: reset propagation
     ///
     /// @tparam propagator_state_t Type of Propagator state
@@ -1181,21 +1188,6 @@ class CombinatorialKalmanFilter {
     const Logger& logger() const { return *actorLogger; }
   };
 
-  template <typename source_link_accessor_t, typename parameters_t>
-  class Aborter {
-   public:
-    /// Broadcast the action type
-    using action_type = Actor<source_link_accessor_t, parameters_t>;
-
-    template <typename propagator_state_t, typename stepper_t,
-              typename navigator_t, typename result_t>
-    bool operator()(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-                    const navigator_t& /*navigator*/, const result_t& result,
-                    const Logger& /*logger*/) const {
-      return !result.lastError.ok() || result.finished;
-    }
-  };
-
   /// Void path limit reached aborter to replace the default since the path
   /// limit is handled in the CKF actor internally.
   struct StubPathLimitReached {
@@ -1203,9 +1195,15 @@ class CombinatorialKalmanFilter {
 
     template <typename propagator_state_t, typename stepper_t,
               typename navigator_t>
-    bool operator()(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-                    const navigator_t& /*navigator*/,
-                    const Logger& /*logger*/) const {
+    void act(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+             const navigator_t& /*navigator*/, const Logger& /*logger*/) const {
+    }
+
+    template <typename propagator_state_t, typename stepper_t,
+              typename navigator_t>
+    bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+               const navigator_t& /*navigator*/,
+               const Logger& /*logger*/) const {
       return false;
     }
   };
@@ -1238,17 +1236,13 @@ class CombinatorialKalmanFilter {
     using SourceLinkAccessor =
         SourceLinkAccessorDelegate<source_link_iterator_t>;
 
-    // Create the ActionList and AbortList
-    using CombinatorialKalmanFilterAborter =
-        Aborter<SourceLinkAccessor, parameters_t>;
+    // Create the ActorList
     using CombinatorialKalmanFilterActor =
         Actor<SourceLinkAccessor, parameters_t>;
-    using Actors = ActionList<CombinatorialKalmanFilterActor>;
-    using Aborters = AbortList<CombinatorialKalmanFilterAborter>;
+    using Actors = ActorList<CombinatorialKalmanFilterActor>;
 
     // Create relevant options for the propagation options
-    using PropagatorOptions =
-        typename propagator_t::template Options<Actors, Aborters>;
+    using PropagatorOptions = typename propagator_t::template Options<Actors>;
     PropagatorOptions propOptions(tfOptions.geoContext,
                                   tfOptions.magFieldContext);
 
@@ -1257,7 +1251,7 @@ class CombinatorialKalmanFilter {
 
     // Catch the actor
     auto& combKalmanActor =
-        propOptions.actionList.template get<CombinatorialKalmanFilterActor>();
+        propOptions.actorList.template get<CombinatorialKalmanFilterActor>();
     combKalmanActor.targetReached.surface = tfOptions.targetSurface;
     combKalmanActor.multipleScattering = tfOptions.multipleScattering;
     combKalmanActor.energyLoss = tfOptions.energyLoss;
diff --git a/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp b/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp
index 0b1f9d5e78d..0cc9afaf17a 100644
--- a/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp
+++ b/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp
@@ -75,20 +75,6 @@ struct GaussianSumFitter {
   /// The actor type
   using GsfActor = detail::GsfActor<bethe_heitler_approx_t, traj_t>;
 
-  /// This allows to break the propagation by setting the navigationBreak
-  /// TODO refactor once we can do this more elegantly
-  struct NavigationBreakAborter {
-    NavigationBreakAborter() = default;
-
-    template <typename propagator_state_t, typename stepper_t,
-              typename navigator_t>
-    bool operator()(propagator_state_t& state, const stepper_t& /*stepper*/,
-                    const navigator_t& navigator,
-                    const Logger& /*logger*/) const {
-      return navigator.navigationBreak(state.navigation);
-    }
-  };
-
   /// @brief The fit function for the Direct navigator
   template <typename source_link_it_t, typename start_parameters_t,
             typename track_container_t, template <typename> class holder_t>
@@ -104,17 +90,15 @@ struct GaussianSumFitter {
 
     // Initialize the forward propagation with the DirectNavigator
     auto fwdPropInitializer = [&sSequence, this](const auto& opts) {
-      using Actors = ActionList<GsfActor>;
-      using Aborters = AbortList<NavigationBreakAborter>;
-      using PropagatorOptions =
-          typename propagator_t::template Options<Actors, Aborters>;
+      using Actors = ActorList<GsfActor>;
+      using PropagatorOptions = typename propagator_t::template Options<Actors>;
 
       PropagatorOptions propOptions(opts.geoContext, opts.magFieldContext);
 
       propOptions.setPlainOptions(opts.propagatorPlainOptions);
 
       propOptions.navigation.surfaces = sSequence;
-      propOptions.actionList.template get<GsfActor>()
+      propOptions.actorList.template get<GsfActor>()
           .m_cfg.bethe_heitler_approx = &m_betheHeitlerApproximation;
 
       return propOptions;
@@ -122,10 +106,8 @@ struct GaussianSumFitter {
 
     // Initialize the backward propagation with the DirectNavigator
     auto bwdPropInitializer = [&sSequence, this](const auto& opts) {
-      using Actors = ActionList<GsfActor>;
-      using Aborters = AbortList<>;
-      using PropagatorOptions =
-          typename propagator_t::template Options<Actors, Aborters>;
+      using Actors = ActorList<GsfActor>;
+      using PropagatorOptions = typename propagator_t::template Options<Actors>;
 
       std::vector<const Surface*> backwardSequence(
           std::next(sSequence.rbegin()), sSequence.rend());
@@ -136,7 +118,7 @@ struct GaussianSumFitter {
       propOptions.setPlainOptions(opts.propagatorPlainOptions);
 
       propOptions.navigation.surfaces = backwardSequence;
-      propOptions.actionList.template get<GsfActor>()
+      propOptions.actorList.template get<GsfActor>()
           .m_cfg.bethe_heitler_approx = &m_betheHeitlerApproximation;
 
       return propOptions;
@@ -159,16 +141,14 @@ struct GaussianSumFitter {
 
     // Initialize the forward propagation with the DirectNavigator
     auto fwdPropInitializer = [this](const auto& opts) {
-      using Actors = ActionList<GsfActor>;
-      using Aborters = AbortList<EndOfWorldReached, NavigationBreakAborter>;
-      using PropagatorOptions =
-          typename propagator_t::template Options<Actors, Aborters>;
+      using Actors = ActorList<GsfActor, EndOfWorldReached>;
+      using PropagatorOptions = typename propagator_t::template Options<Actors>;
 
       PropagatorOptions propOptions(opts.geoContext, opts.magFieldContext);
 
       propOptions.setPlainOptions(opts.propagatorPlainOptions);
 
-      propOptions.actionList.template get<GsfActor>()
+      propOptions.actorList.template get<GsfActor>()
           .m_cfg.bethe_heitler_approx = &m_betheHeitlerApproximation;
 
       return propOptions;
@@ -176,16 +156,14 @@ struct GaussianSumFitter {
 
     // Initialize the backward propagation with the DirectNavigator
     auto bwdPropInitializer = [this](const auto& opts) {
-      using Actors = ActionList<GsfActor>;
-      using Aborters = AbortList<EndOfWorldReached>;
-      using PropagatorOptions =
-          typename propagator_t::template Options<Actors, Aborters>;
+      using Actors = ActorList<GsfActor, EndOfWorldReached>;
+      using PropagatorOptions = typename propagator_t::template Options<Actors>;
 
       PropagatorOptions propOptions(opts.geoContext, opts.magFieldContext);
 
       propOptions.setPlainOptions(opts.propagatorPlainOptions);
 
-      propOptions.actionList.template get<GsfActor>()
+      propOptions.actorList.template get<GsfActor>()
           .m_cfg.bethe_heitler_approx = &m_betheHeitlerApproximation;
 
       return propOptions;
@@ -266,7 +244,7 @@ struct GaussianSumFitter {
       auto fwdPropOptions = fwdPropInitializer(options);
 
       // Catch the actor and set the measurements
-      auto& actor = fwdPropOptions.actionList.template get<GsfActor>();
+      auto& actor = fwdPropOptions.actorList.template get<GsfActor>();
       actor.setOptions(options);
       actor.m_cfg.inputMeasurements = &inputMeasurements;
       actor.m_cfg.numberMeasurements = inputMeasurements.size();
@@ -337,7 +315,7 @@ struct GaussianSumFitter {
     auto bwdResult = [&]() {
       auto bwdPropOptions = bwdPropInitializer(options);
 
-      auto& actor = bwdPropOptions.actionList.template get<GsfActor>();
+      auto& actor = bwdPropOptions.actorList.template get<GsfActor>();
       actor.setOptions(options);
       actor.m_cfg.inputMeasurements = &inputMeasurements;
       actor.m_cfg.inReversePass = true;
diff --git a/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp b/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp
index deed734ac92..c00012e7cf5 100644
--- a/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp
+++ b/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp
@@ -23,8 +23,7 @@
 #include "Acts/Geometry/TrackingVolume.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
 #include "Acts/Material/MaterialSlab.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/ConstrainedStep.hpp"
 #include "Acts/Propagator/DirectNavigator.hpp"
 #include "Acts/Propagator/Navigator.hpp"
@@ -418,9 +417,9 @@ class Gx2Fitter {
     /// @param result is the mutable result state object
     template <typename propagator_state_t, typename stepper_t,
               typename navigator_t>
-    void operator()(propagator_state_t& state, const stepper_t& stepper,
-                    const navigator_t& navigator, result_type& result,
-                    const Logger& /*logger*/) const {
+    void act(propagator_state_t& state, const stepper_t& stepper,
+             const navigator_t& navigator, result_type& result,
+             const Logger& /*logger*/) const {
       assert(result.fittedStates && "No MultiTrajectory set");
 
       // Check if we can stop to propagate
@@ -629,20 +628,12 @@ class Gx2Fitter {
         }
       }
     }
-  };
-
-  /// Aborter can stay like this probably
-  template <typename parameters_t>
-  class Aborter {
-   public:
-    /// Broadcast the result_type
-    using action_type = Actor<parameters_t>;
 
     template <typename propagator_state_t, typename stepper_t,
               typename navigator_t, typename result_t>
-    bool operator()(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-                    const navigator_t& /*navigator*/, const result_t& result,
-                    const Logger& /*logger*/) const {
+    bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+               const navigator_t& /*navigator*/, const result_t& result,
+               const Logger& /*logger*/) const {
       if (!result.result.ok() || result.finished) {
         return true;
       }
@@ -698,17 +689,13 @@ class Gx2Fitter {
     // option to the Actor.
     const bool multipleScattering = gx2fOptions.multipleScattering;
 
-    /// Fully understand Aborter, Actor, Result later
-    // Create the ActionList and AbortList
-    using GX2FAborter = Aborter<parameters_t>;
+    // Create the ActorList
     using GX2FActor = Actor<parameters_t>;
 
     using GX2FResult = typename GX2FActor::result_type;
-    using Actors = Acts::ActionList<GX2FActor>;
-    using Aborters = Acts::AbortList<GX2FAborter>;
+    using Actors = Acts::ActorList<GX2FActor>;
 
-    using PropagatorOptions =
-        typename propagator_t::template Options<Actors, Aborters>;
+    using PropagatorOptions = typename propagator_t::template Options<Actors>;
 
     start_parameters_t params = sParameters;
     BoundVector deltaParams = BoundVector::Zero();
@@ -768,7 +755,7 @@ class Gx2Fitter {
         propagatorOptions.navigation.insertExternalSurface(surfaceId);
       }
 
-      auto& gx2fActor = propagatorOptions.actionList.template get<GX2FActor>();
+      auto& gx2fActor = propagatorOptions.actorList.template get<GX2FActor>();
       gx2fActor.inputMeasurements = &inputMeasurements;
       gx2fActor.multipleScattering = multipleScattering;
       gx2fActor.extensions = gx2fOptions.extensions;
@@ -1028,7 +1015,7 @@ class Gx2Fitter {
       Acts::MagneticFieldContext magCtx = gx2fOptions.magFieldContext;
       // Set options for propagator
       PropagatorOptions propagatorOptions(geoCtx, magCtx);
-      auto& gx2fActor = propagatorOptions.actionList.template get<GX2FActor>();
+      auto& gx2fActor = propagatorOptions.actorList.template get<GX2FActor>();
       gx2fActor.inputMeasurements = &inputMeasurements;
       gx2fActor.multipleScattering = multipleScattering;
       gx2fActor.extensions = gx2fOptions.extensions;
diff --git a/Core/include/Acts/TrackFitting/KalmanFitter.hpp b/Core/include/Acts/TrackFitting/KalmanFitter.hpp
index f5e2a10e7ff..36478935ceb 100644
--- a/Core/include/Acts/TrackFitting/KalmanFitter.hpp
+++ b/Core/include/Acts/TrackFitting/KalmanFitter.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2016-2023 CERN for the benefit of the Acts project
+// Copyright (C) 2016-2024 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
@@ -18,8 +18,7 @@
 #include "Acts/EventData/VectorMultiTrajectory.hpp"
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/DirectNavigator.hpp"
 #include "Acts/Propagator/Propagator.hpp"
 #include "Acts/Propagator/StandardAborters.hpp"
@@ -350,9 +349,9 @@ class KalmanFitter {
     /// @param result is the mutable result state object
     template <typename propagator_state_t, typename stepper_t,
               typename navigator_t>
-    void operator()(propagator_state_t& state, const stepper_t& stepper,
-                    const navigator_t& navigator, result_type& result,
-                    const Logger& /*logger*/) const {
+    void act(propagator_state_t& state, const stepper_t& stepper,
+             const navigator_t& navigator, result_type& result,
+             const Logger& /*logger*/) const {
       assert(result.fittedStates && "No MultiTrajectory set");
 
       if (result.finished) {
@@ -463,7 +462,7 @@ class KalmanFitter {
             // Remember the track fitting is done
             result.finished = true;
           }
-        } else if (targetReached(state, stepper, navigator, logger())) {
+        } else if (targetReached.check(state, stepper, navigator, logger())) {
           ACTS_VERBOSE("Completing with fitted track parameter");
           // Transport & bind the parameter to the final surface
           auto res = stepper.boundState(state.stepping, *targetReached.surface,
@@ -500,6 +499,17 @@ class KalmanFitter {
       }
     }
 
+    template <typename propagator_state_t, typename stepper_t,
+              typename navigator_t>
+    bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+               const navigator_t& /*navigator*/, const result_type& result,
+               const Logger& /*logger*/) const {
+      if (!result.result.ok() || result.finished) {
+        return true;
+      }
+      return false;
+    }
+
     /// @brief Kalman actor operation: reverse direction
     ///
     /// @tparam propagator_state_t is the type of Propagator state
@@ -1041,25 +1051,6 @@ class KalmanFitter {
     }
   };
 
-  template <typename parameters_t>
-  class Aborter {
-   public:
-    /// Broadcast the action type
-    using action_type = Actor<parameters_t>;
-
-    template <typename propagator_state_t, typename stepper_t,
-              typename navigator_t>
-    bool operator()(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-                    const navigator_t& /*navigator*/,
-                    const typename action_type::result_type& result,
-                    const Logger& /*logger*/) const {
-      if (!result.result.ok() || result.finished) {
-        return true;
-      }
-      return false;
-    }
-  };
-
  public:
   /// Fit implementation of the forward filter, calls the
   /// the filter and smoother/reversed filter
@@ -1105,15 +1096,12 @@ class KalmanFitter {
       inputMeasurements.emplace(geoId, std::move(sl));
     }
 
-    // Create the ActionList and AbortList
-    using KalmanAborter = Aborter<parameters_t>;
+    // Create the ActorList
     using KalmanActor = Actor<parameters_t>;
 
     using KalmanResult = typename KalmanActor::result_type;
-    using Actors = ActionList<KalmanActor>;
-    using Aborters = AbortList<KalmanAborter>;
-    using PropagatorOptions =
-        typename propagator_t::template Options<Actors, Aborters>;
+    using Actors = ActorList<KalmanActor>;
+    using PropagatorOptions = typename propagator_t::template Options<Actors>;
 
     // Create relevant options for the propagation options
     PropagatorOptions propagatorOptions(kfOptions.geoContext,
@@ -1129,8 +1117,7 @@ class KalmanFitter {
     }
 
     // Catch the actor and set the measurements
-    auto& kalmanActor =
-        propagatorOptions.actionList.template get<KalmanActor>();
+    auto& kalmanActor = propagatorOptions.actorList.template get<KalmanActor>();
     kalmanActor.inputMeasurements = &inputMeasurements;
     kalmanActor.targetReached.surface = kfOptions.referenceSurface;
     kalmanActor.targetSurfaceStrategy = kfOptions.referenceSurfaceStrategy;
@@ -1195,15 +1182,12 @@ class KalmanFitter {
       inputMeasurements.emplace(geoId, std::move(sl));
     }
 
-    // Create the ActionList and AbortList
-    using KalmanAborter = Aborter<parameters_t>;
+    // Create the ActorList
     using KalmanActor = Actor<parameters_t>;
 
     using KalmanResult = typename KalmanActor::result_type;
-    using Actors = ActionList<KalmanActor>;
-    using Aborters = AbortList<KalmanAborter>;
-    using PropagatorOptions =
-        typename propagator_t::template Options<Actors, Aborters>;
+    using Actors = ActorList<KalmanActor>;
+    using PropagatorOptions = typename propagator_t::template Options<Actors>;
 
     // Create relevant options for the propagation options
     PropagatorOptions propagatorOptions(kfOptions.geoContext,
@@ -1213,8 +1197,7 @@ class KalmanFitter {
     propagatorOptions.setPlainOptions(kfOptions.propagatorPlainOptions);
 
     // Catch the actor and set the measurements
-    auto& kalmanActor =
-        propagatorOptions.actionList.template get<KalmanActor>();
+    auto& kalmanActor = propagatorOptions.actorList.template get<KalmanActor>();
     kalmanActor.inputMeasurements = &inputMeasurements;
     kalmanActor.targetReached.surface = kfOptions.referenceSurface;
     kalmanActor.targetSurfaceStrategy = kfOptions.referenceSurfaceStrategy;
diff --git a/Core/include/Acts/TrackFitting/detail/GsfActor.hpp b/Core/include/Acts/TrackFitting/detail/GsfActor.hpp
index 56d6cecd262..9babe83a10a 100644
--- a/Core/include/Acts/TrackFitting/detail/GsfActor.hpp
+++ b/Core/include/Acts/TrackFitting/detail/GsfActor.hpp
@@ -145,9 +145,9 @@ struct GsfActor {
   /// @param result is the mutable result state object
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, result_type& result,
-                  const Logger& /*logger*/) const {
+  void act(propagator_state_t& state, const stepper_t& stepper,
+           const navigator_t& navigator, result_type& result,
+           const Logger& /*logger*/) const {
     assert(result.fittedStates && "No MultiTrajectory set");
 
     // Return is we found an error earlier
@@ -333,6 +333,14 @@ struct GsfActor {
     }
   }
 
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool check(propagator_state_t& state, const stepper_t& /*stepper*/,
+             const navigator_t& navigator, result_type& /*result*/,
+             const Logger& /*logger*/) const {
+    return navigator.navigationBreak(state.navigation);
+  }
+
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
   void convoluteComponents(propagator_state_t& state, const stepper_t& stepper,
diff --git a/Core/src/Material/SurfaceMaterialMapper.cpp b/Core/src/Material/SurfaceMaterialMapper.cpp
index a8d62f0e75c..13109038c47 100644
--- a/Core/src/Material/SurfaceMaterialMapper.cpp
+++ b/Core/src/Material/SurfaceMaterialMapper.cpp
@@ -21,8 +21,7 @@
 #include "Acts/Material/ISurfaceMaterial.hpp"
 #include "Acts/Material/MaterialInteraction.hpp"
 #include "Acts/Material/ProtoSurfaceMaterial.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/Navigator.hpp"
 #include "Acts/Propagator/Propagator.hpp"
 #include "Acts/Propagator/SurfaceCollector.hpp"
@@ -240,12 +239,11 @@ void Acts::SurfaceMaterialMapper::mapInteraction(
   // Prepare Action list and abort list
   using MaterialSurfaceCollector = SurfaceCollector<MaterialSurface>;
   using MaterialVolumeCollector = VolumeCollector<MaterialVolume>;
-  using ActionList =
-      ActionList<MaterialSurfaceCollector, MaterialVolumeCollector>;
-  using AbortList = AbortList<EndOfWorldReached>;
+  using ActorList = ActorList<MaterialSurfaceCollector, MaterialVolumeCollector,
+                              EndOfWorldReached>;
 
-  StraightLinePropagator::Options<ActionList, AbortList> options(
-      mState.geoContext, mState.magFieldContext);
+  StraightLinePropagator::Options<ActorList> options(mState.geoContext,
+                                                     mState.magFieldContext);
 
   // Now collect the material layers by using the straight line propagator
   const auto& result = m_propagator.propagate(start, options).value();
diff --git a/Core/src/Material/VolumeMaterialMapper.cpp b/Core/src/Material/VolumeMaterialMapper.cpp
index 2bb9113f4a9..67d54d863ef 100644
--- a/Core/src/Material/VolumeMaterialMapper.cpp
+++ b/Core/src/Material/VolumeMaterialMapper.cpp
@@ -24,8 +24,7 @@
 #include "Acts/Material/MaterialGridHelper.hpp"
 #include "Acts/Material/MaterialInteraction.hpp"
 #include "Acts/Material/ProtoVolumeMaterial.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/SurfaceCollector.hpp"
 #include "Acts/Propagator/VolumeCollector.hpp"
 #include "Acts/Surfaces/SurfaceArray.hpp"
@@ -374,11 +373,11 @@ void Acts::VolumeMaterialMapper::mapMaterialTrack(
   // Prepare Action list and abort list
   using BoundSurfaceCollector = SurfaceCollector<BoundSurfaceSelector>;
   using MaterialVolumeCollector = VolumeCollector<MaterialVolumeSelector>;
-  using ActionList = ActionList<BoundSurfaceCollector, MaterialVolumeCollector>;
-  using AbortList = AbortList<EndOfWorldReached>;
+  using ActionList = ActorList<BoundSurfaceCollector, MaterialVolumeCollector,
+                               EndOfWorldReached>;
 
-  StraightLinePropagator::Options<ActionList, AbortList> options(
-      mState.geoContext, mState.magFieldContext);
+  StraightLinePropagator::Options<ActionList> options(mState.geoContext,
+                                                      mState.magFieldContext);
 
   // Now collect the material volume by using the straight line propagator
   const auto& result = m_propagator.propagate(start, options).value();
diff --git a/Examples/Algorithms/Propagation/include/ActsExamples/Propagation/PropagatorInterface.hpp b/Examples/Algorithms/Propagation/include/ActsExamples/Propagation/PropagatorInterface.hpp
index cc13142616f..48578e26c9d 100644
--- a/Examples/Algorithms/Propagation/include/ActsExamples/Propagation/PropagatorInterface.hpp
+++ b/Examples/Algorithms/Propagation/include/ActsExamples/Propagation/PropagatorInterface.hpp
@@ -67,11 +67,11 @@ class ConcretePropagator : public PropagatorInterface {
     using SteppingLogger = Acts::detail::SteppingLogger;
     using EndOfWorld = Acts::EndOfWorldReached;
 
-    // Action list and abort list
-    using ActionList = Acts::ActionList<SteppingLogger, MaterialInteractor>;
-    using AbortList = Acts::AbortList<EndOfWorld>;
+    // Actor list
+    using ActorList =
+        Acts::ActorList<SteppingLogger, MaterialInteractor, EndOfWorld>;
     using PropagatorOptions =
-        typename propagator_t::template Options<ActionList, AbortList>;
+        typename propagator_t::template Options<ActorList>;
 
     PropagatorOptions options(context.geoContext, context.magFieldContext);
     // Activate loop protection at some pt value
@@ -79,13 +79,13 @@ class ConcretePropagator : public PropagatorInterface {
         startParameters.transverseMomentum() < cfg.ptLoopers;
 
     // Switch the material interaction on/off & eventually into logging mode
-    auto& mInteractor = options.actionList.template get<MaterialInteractor>();
+    auto& mInteractor = options.actorList.template get<MaterialInteractor>();
     mInteractor.multipleScattering = cfg.multipleScattering;
     mInteractor.energyLoss = cfg.energyLoss;
     mInteractor.recordInteractions = cfg.recordMaterialInteractions;
 
     // Switch the logger to sterile, e.g. for timing checks
-    auto& sLogger = options.actionList.template get<SteppingLogger>();
+    auto& sLogger = options.actorList.template get<SteppingLogger>();
     sLogger.sterile = cfg.sterileLogger;
     // Set a maximum step size
     options.stepping.maxStepSize = cfg.maxStepSize;
diff --git a/Examples/Algorithms/TrackFinding/src/TrackFindingAlgorithm.cpp b/Examples/Algorithms/TrackFinding/src/TrackFindingAlgorithm.cpp
index 60f08e98a52..a3967b933da 100644
--- a/Examples/Algorithms/TrackFinding/src/TrackFindingAlgorithm.cpp
+++ b/Examples/Algorithms/TrackFinding/src/TrackFindingAlgorithm.cpp
@@ -19,7 +19,6 @@
 #include "Acts/EventData/VectorMultiTrajectory.hpp"
 #include "Acts/EventData/VectorTrackContainer.hpp"
 #include "Acts/Geometry/GeometryIdentifier.hpp"
-#include "Acts/Propagator/AbortList.hpp"
 #include "Acts/Propagator/MaterialInteractor.hpp"
 #include "Acts/Propagator/Navigator.hpp"
 #include "Acts/Propagator/Propagator.hpp"
@@ -370,9 +369,8 @@ ProcessCode TrackFindingAlgorithm::execute(const AlgorithmContext& ctx) const {
   secondOptions.targetSurface = m_cfg.reverseSearch ? nullptr : pSurface.get();
 
   using Extrapolator = Acts::Propagator<Acts::SympyStepper, Acts::Navigator>;
-  using ExtrapolatorOptions =
-      Extrapolator::template Options<Acts::ActionList<Acts::MaterialInteractor>,
-                                     Acts::AbortList<Acts::EndOfWorldReached>>;
+  using ExtrapolatorOptions = Extrapolator::template Options<
+      Acts::ActorList<Acts::MaterialInteractor, Acts::EndOfWorldReached>>;
 
   Extrapolator extrapolator(
       Acts::SympyStepper(m_cfg.magneticField),
diff --git a/Fatras/include/ActsFatras/Kernel/Simulation.hpp b/Fatras/include/ActsFatras/Kernel/Simulation.hpp
index c60bed02b9f..d13c0ac4149 100644
--- a/Fatras/include/ActsFatras/Kernel/Simulation.hpp
+++ b/Fatras/include/ActsFatras/Kernel/Simulation.hpp
@@ -13,8 +13,7 @@
 #include "Acts/EventData/TrackParameters.hpp"
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/Propagator.hpp"
 #include "Acts/Propagator/StandardAborters.hpp"
 #include "Acts/Utilities/Logger.hpp"
@@ -79,19 +78,17 @@ struct SingleParticleSimulation {
     // propagator-related additional types
     using Actor = detail::SimulationActor<generator_t, decay_t, interactions_t,
                                           hit_surface_selector_t>;
-    using Aborter = typename Actor::ParticleNotAlive;
     using Result = typename Actor::result_type;
-    using Actions = Acts::ActionList<Actor>;
-    using Abort = Acts::AbortList<Aborter, Acts::EndOfWorldReached>;
+    using ActorList = Acts::ActorList<Actor>;
     using PropagatorOptions =
-        typename propagator_t::template Options<Actions, Abort>;
+        typename propagator_t::template Options<ActorList>;
 
     // Construct per-call options.
     PropagatorOptions options(geoCtx, magCtx);
     options.stepping.maxStepSize = maxStepSize;
     options.pathLimit = pathLimit;
     // setup the interactor as part of the propagator options
-    auto &actor = options.actionList.template get<Actor>();
+    auto &actor = options.actorList.template get<Actor>();
     actor.generator = &generator;
     actor.decay = decay;
     actor.interactions = interactions;
diff --git a/Fatras/include/ActsFatras/Kernel/detail/SimulationActor.hpp b/Fatras/include/ActsFatras/Kernel/detail/SimulationActor.hpp
index 91482d3abd6..ffcd76891a6 100644
--- a/Fatras/include/ActsFatras/Kernel/detail/SimulationActor.hpp
+++ b/Fatras/include/ActsFatras/Kernel/detail/SimulationActor.hpp
@@ -41,24 +41,6 @@ template <typename generator_t, typename decay_t, typename interactions_t,
 struct SimulationActor {
   using result_type = SimulationResult;
 
-  /// Abort if the particle was killed during a previous interaction.
-  struct ParticleNotAlive {
-    // This references the SimulationActor to automatically access its result
-    // type.
-    using action_type = SimulationActor;
-
-    template <typename propagator_state_t, typename stepper_t,
-              typename navigator_t>
-    constexpr bool operator()(propagator_state_t & /*state*/,
-                              const stepper_t & /*stepper*/,
-                              const navigator_t & /*navigator*/,
-                              const result_type &result,
-                              const Acts::Logger & /*logger*/) const {
-      // must return true if the propagation should abort
-      return !result.isAlive;
-    }
-  };
-
   /// Random number generator used for the simulation.
   generator_t *generator = nullptr;
   /// Decay module.
@@ -84,9 +66,9 @@ struct SimulationActor {
   /// @param logger a logger instance
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  void operator()(propagator_state_t &state, stepper_t &stepper,
-                  navigator_t &navigator, result_type &result,
-                  const Acts::Logger &logger) const {
+  void act(propagator_state_t &state, stepper_t &stepper,
+           navigator_t &navigator, result_type &result,
+           const Acts::Logger &logger) const {
     assert(generator && "The generator pointer must be valid");
 
     // actors are called once more after the propagation terminated
@@ -94,7 +76,7 @@ struct SimulationActor {
       return;
     }
 
-    if (Acts::EndOfWorldReached{}(state, stepper, navigator, logger)) {
+    if (Acts::EndOfWorldReached{}.check(state, stepper, navigator, logger)) {
       result.isAlive = false;
       return;
     }
@@ -220,6 +202,15 @@ struct SimulationActor {
                    after.qOverP(), after.time());
   }
 
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool check(propagator_state_t & /*state*/, const stepper_t & /*stepper*/,
+             const navigator_t & /*navigator*/, const result_type &result,
+             const Acts::Logger & /*logger*/) const {
+    // must return true if the propagation should abort
+    return !result.isAlive;
+  }
+
   /// Construct the current particle state from the propagation state.
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
diff --git a/Tests/CommonHelpers/Acts/Tests/CommonHelpers/MeasurementsCreator.hpp b/Tests/CommonHelpers/Acts/Tests/CommonHelpers/MeasurementsCreator.hpp
index f88d86c4c88..ae7f963ab03 100644
--- a/Tests/CommonHelpers/Acts/Tests/CommonHelpers/MeasurementsCreator.hpp
+++ b/Tests/CommonHelpers/Acts/Tests/CommonHelpers/MeasurementsCreator.hpp
@@ -13,8 +13,7 @@
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/Geometry/GeometryHierarchyMap.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/StandardAborters.hpp"
 #include "Acts/Utilities/Logger.hpp"
 
@@ -59,7 +58,7 @@ struct MeasurementsCreator {
   // how far away from the measurements the outliers should be
   double distanceOutlier = 10 * Acts::UnitConstants::mm;
 
-  /// @brief Operator that is callable by an ActionList. The function
+  /// @brief Operator that is callable by an ActorList. The function
   /// collects the surfaces
   ///
   /// @tparam propagator_state_t Type of the propagator state
@@ -70,9 +69,9 @@ struct MeasurementsCreator {
   /// @param [in] state State of the propagator
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, result_type& result,
-                  const Logger& logger) const {
+  void act(propagator_state_t& state, const stepper_t& stepper,
+           const navigator_t& navigator, result_type& result,
+           const Logger& logger) const {
     using namespace Acts::UnitLiterals;
 
     // only generate measurements on surfaces
@@ -144,6 +143,14 @@ struct MeasurementsCreator {
                                              geoId, sourceId);
     }
   }
+
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+             const navigator_t& /*navigator*/, result_type& /*result*/,
+             const Logger& /*logger*/) const {
+    return false;
+  }
 };
 
 /// Propagate the track create smeared measurements from local coordinates.
@@ -155,14 +162,13 @@ Measurements createMeasurements(const propagator_t& propagator,
                                 const MeasurementResolutionMap& resolutions,
                                 std::default_random_engine& rng,
                                 std::size_t sourceId = 0u) {
-  using Actions = Acts::ActionList<MeasurementsCreator>;
-  using Aborters = Acts::AbortList<Acts::EndOfWorldReached>;
-  using PropagatorOptions =
-      typename propagator_t::template Options<Actions, Aborters>;
+  using ActorList =
+      Acts::ActorList<MeasurementsCreator, Acts::EndOfWorldReached>;
+  using PropagatorOptions = typename propagator_t::template Options<ActorList>;
 
   // Set options for propagator
   PropagatorOptions options(geoCtx, magCtx);
-  auto& creator = options.actionList.template get<MeasurementsCreator>();
+  auto& creator = options.actorList.template get<MeasurementsCreator>();
   creator.resolutions = resolutions;
   creator.rng = &rng;
   creator.sourceId = sourceId;
diff --git a/Tests/IntegrationTests/NavigatorConsistency.cpp b/Tests/IntegrationTests/NavigatorConsistency.cpp
index c4a380a5d3f..a46f842a28a 100644
--- a/Tests/IntegrationTests/NavigatorConsistency.cpp
+++ b/Tests/IntegrationTests/NavigatorConsistency.cpp
@@ -69,11 +69,9 @@ template <typename propagator_t>
 void runSelfConsistencyTest(const propagator_t& prop,
                             const CurvilinearTrackParameters& start,
                             const Acts::Logger& logger) {
-  // Action list and abort list
-  using ActionListType = ActionList<SurfaceCollector>;
-  using AbortListType = AbortList<>;
-  using Options =
-      typename propagator_t::template Options<ActionListType, AbortListType>;
+  // Actor list
+  using ActorList = ActorList<SurfaceCollector>;
+  using Options = typename propagator_t::template Options<ActorList>;
 
   // forward surface test
   Options fwdOptions(tgContext, mfContext);
@@ -81,7 +79,7 @@ void runSelfConsistencyTest(const propagator_t& prop,
 
   // get the surface collector and configure it
   auto& fwdSurfaceCollector =
-      fwdOptions.actionList.template get<SurfaceCollector>();
+      fwdOptions.actorList.template get<SurfaceCollector>();
   fwdSurfaceCollector.selector.selectSensitive = true;
   fwdSurfaceCollector.selector.selectMaterial = true;
   fwdSurfaceCollector.selector.selectPassive = true;
@@ -106,7 +104,7 @@ void runSelfConsistencyTest(const propagator_t& prop,
 
   // get the surface collector and configure it
   auto& bwdMSurfaceCollector =
-      bwdOptions.actionList.template get<SurfaceCollector>();
+      bwdOptions.actorList.template get<SurfaceCollector>();
   bwdMSurfaceCollector.selector.selectSensitive = true;
   bwdMSurfaceCollector.selector.selectMaterial = true;
   bwdMSurfaceCollector.selector.selectPassive = true;
@@ -141,7 +139,7 @@ void runSelfConsistencyTest(const propagator_t& prop,
 
   // get the surface collector and configure it
   auto& fwdStepSurfaceCollector =
-      fwdOptions.actionList.template get<SurfaceCollector>();
+      fwdOptions.actorList.template get<SurfaceCollector>();
   fwdStepSurfaceCollector.selector.selectSensitive = true;
   fwdStepSurfaceCollector.selector.selectMaterial = true;
   fwdStepSurfaceCollector.selector.selectPassive = true;
@@ -192,7 +190,7 @@ void runSelfConsistencyTest(const propagator_t& prop,
 
   // get the surface collector and configure it
   auto& bwdStepSurfaceCollector =
-      bwdOptions.actionList.template get<SurfaceCollector>();
+      bwdOptions.actorList.template get<SurfaceCollector>();
   bwdStepSurfaceCollector.selector.selectSensitive = true;
   bwdStepSurfaceCollector.selector.selectMaterial = true;
   bwdStepSurfaceCollector.selector.selectPassive = true;
@@ -256,13 +254,11 @@ void runConsistencyTest(const propagator_probe_t& propProbe,
                         const CurvilinearTrackParameters& start,
                         const Acts::Logger& logger) {
   // Action list and abort list
-  using ActionListType = ActionList<SurfaceCollector>;
-  using AbortListType = AbortList<>;
+  using ActorList = ActorList<SurfaceCollector>;
 
   auto run = [&](const auto& prop) {
     using propagator_t = std::decay_t<decltype(prop)>;
-    using Options =
-        typename propagator_t::template Options<ActionListType, AbortListType>;
+    using Options = typename propagator_t::template Options<ActorList>;
 
     // forward surface test
     Options fwdOptions(tgContext, mfContext);
@@ -271,7 +267,7 @@ void runConsistencyTest(const propagator_probe_t& propProbe,
 
     // get the surface collector and configure it
     auto& fwdSurfaceCollector =
-        fwdOptions.actionList.template get<SurfaceCollector>();
+        fwdOptions.actorList.template get<SurfaceCollector>();
     fwdSurfaceCollector.selector.selectSensitive = true;
     fwdSurfaceCollector.selector.selectMaterial = true;
     fwdSurfaceCollector.selector.selectPassive = true;
diff --git a/Tests/IntegrationTests/PropagationBentTracks.cpp b/Tests/IntegrationTests/PropagationBentTracks.cpp
index 5b7a96404f7..e63edc97ba6 100644
--- a/Tests/IntegrationTests/PropagationBentTracks.cpp
+++ b/Tests/IntegrationTests/PropagationBentTracks.cpp
@@ -56,8 +56,8 @@ std::vector<double> xPositionsOfPassedSurfaces(Acts::Navigator::Config navCfg,
       Acts::Vector4(0.01, 0, 0, 0), dir.normalized(), 1 / 1_GeV, std::nullopt,
       Acts::ParticleHypothesis::pion());
 
-  Propagator::Options<Acts::ActionList<Acts::detail::SteppingLogger>,
-                      Acts::AbortList<Acts::EndOfWorldReached>>
+  Propagator::Options<
+      Acts::ActorList<Acts::detail::SteppingLogger, Acts::EndOfWorldReached>>
       opts(geoCtx, magCtx);
 
   auto res = propagator.propagate(start, opts);
diff --git a/Tests/UnitTests/Core/Material/VolumeMaterialMapperTests.cpp b/Tests/UnitTests/Core/Material/VolumeMaterialMapperTests.cpp
index 98c10e33767..9f06f706a10 100644
--- a/Tests/UnitTests/Core/Material/VolumeMaterialMapperTests.cpp
+++ b/Tests/UnitTests/Core/Material/VolumeMaterialMapperTests.cpp
@@ -26,8 +26,7 @@
 #include "Acts/Material/MaterialSlab.hpp"
 #include "Acts/Material/ProtoVolumeMaterial.hpp"
 #include "Acts/Material/VolumeMaterialMapper.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/Navigator.hpp"
 #include "Acts/Propagator/Propagator.hpp"
 #include "Acts/Propagator/StandardAborters.hpp"
@@ -60,9 +59,9 @@ struct MaterialCollector {
 
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, result_type& result,
-                  const Logger& /*logger*/) const {
+  void act(propagator_state_t& state, const stepper_t& stepper,
+           const navigator_t& navigator, result_type& result,
+           const Logger& /*logger*/) const {
     if (navigator.currentVolume(state.navigation) != nullptr) {
       auto position = stepper.position(state.stepping);
       result.matTrue.push_back(
@@ -76,6 +75,14 @@ struct MaterialCollector {
       result.position.push_back(position);
     }
   }
+
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+             const navigator_t& /*navigator*/, result_type& /*result*/,
+             const Logger& /*logger*/) const {
+    return false;
+  }
 };
 
 }  // namespace Acts
@@ -267,7 +274,7 @@ BOOST_AUTO_TEST_CASE(VolumeMaterialMapper_comparison_tests) {
   MagneticFieldContext mc;
   // Launch propagation and gather result
   using PropagatorOptions = Propagator<StraightLineStepper, Navigator>::Options<
-      ActionList<MaterialCollector>, AbortList<EndOfWorldReached>>;
+      ActorList<MaterialCollector, EndOfWorldReached>>;
   PropagatorOptions po(gc, mc);
   po.stepping.maxStepSize = 1._mm;
   po.maxSteps = 1e6;
diff --git a/Tests/UnitTests/Core/Navigation/DetectorNavigatorTests.cpp b/Tests/UnitTests/Core/Navigation/DetectorNavigatorTests.cpp
index 2ad242c1acc..f58976fa2c7 100644
--- a/Tests/UnitTests/Core/Navigation/DetectorNavigatorTests.cpp
+++ b/Tests/UnitTests/Core/Navigation/DetectorNavigatorTests.cpp
@@ -23,8 +23,7 @@
 #include "Acts/Navigation/DetectorNavigator.hpp"
 #include "Acts/Navigation/DetectorVolumeFinders.hpp"
 #include "Acts/Navigation/InternalNavigation.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/Propagator.hpp"
 #include "Acts/Propagator/StraightLineStepper.hpp"
 #include "Acts/Surfaces/CylinderSurface.hpp"
@@ -48,11 +47,19 @@ struct StateRecorder {
 
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  void operator()(propagator_state_t& state, const stepper_t& /*stepper*/,
-                  const navigator_t& /*navigator*/, result_type& result,
-                  const Acts::Logger& /*logger*/) const {
+  void act(propagator_state_t& state, const stepper_t& /*stepper*/,
+           const navigator_t& /*navigator*/, result_type& result,
+           const Acts::Logger& /*logger*/) const {
     result.push_back(state.navigation);
   }
+
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+             const navigator_t& /*navigator*/, result_type& /*result*/,
+             const Acts::Logger& /*logger*/) const {
+    return false;
+  }
 };
 
 BOOST_AUTO_TEST_SUITE(DetectorNavigator)
@@ -72,9 +79,8 @@ BOOST_AUTO_TEST_CASE(DetectorNavigatorTestsInitialization) {
   using Stepper = Acts::StraightLineStepper;
   using Navigator = Acts::Experimental::DetectorNavigator;
   using Propagator = Acts::Propagator<Stepper, Navigator>;
-  using ActionList = Acts::ActionList<>;
-  using AbortList = Acts::AbortList<>;
-  using PropagatorOptions = Propagator::Options<ActionList, AbortList>;
+  using ActorList = Acts::ActorList<>;
+  using PropagatorOptions = Propagator::Options<ActorList>;
 
   PropagatorOptions options(geoContext, mfContext);
 
@@ -268,9 +274,8 @@ BOOST_AUTO_TEST_CASE(DetectorNavigatorTestsForwardBackward) {
   using Stepper = Acts::StraightLineStepper;
   using Navigator = Acts::Experimental::DetectorNavigator;
   using Propagator = Acts::Propagator<Stepper, Navigator>;
-  using ActionList = Acts::ActionList<StateRecorder>;
-  using AbortList = Acts::AbortList<Acts::EndOfWorldReached>;
-  using PropagatorOptions = Propagator::Options<ActionList, AbortList>;
+  using ActorList = Acts::ActorList<StateRecorder, Acts::EndOfWorldReached>;
+  using PropagatorOptions = Propagator::Options<ActorList>;
 
   Navigator::Config navCfg;
   navCfg.detector = detector.get();
@@ -429,9 +434,8 @@ BOOST_AUTO_TEST_CASE(DetectorNavigatorTestsAmbiguity) {
   using Stepper = Acts::StraightLineStepper;
   using Navigator = Acts::Experimental::DetectorNavigator;
   using Propagator = Acts::Propagator<Stepper, Navigator>;
-  using ActionList = Acts::ActionList<StateRecorder>;
-  using AbortList = Acts::AbortList<Acts::EndOfWorldReached>;
-  using PropagatorOptions = Propagator::Options<ActionList, AbortList>;
+  using ActorList = Acts::ActorList<StateRecorder, Acts::EndOfWorldReached>;
+  using PropagatorOptions = Propagator::Options<ActorList>;
 
   Navigator::Config navCfg;
   navCfg.detector = detector.get();
@@ -545,9 +549,8 @@ BOOST_AUTO_TEST_CASE(DetectorNavigatorTestsMultipleIntersection) {
   using Stepper = Acts::StraightLineStepper;
   using Navigator = Acts::Experimental::DetectorNavigator;
   using Propagator = Acts::Propagator<Stepper, Navigator>;
-  using ActionList = Acts::ActionList<StateRecorder>;
-  using AbortList = Acts::AbortList<Acts::EndOfWorldReached>;
-  using PropagatorOptions = Propagator::Options<ActionList, AbortList>;
+  using ActorList = Acts::ActorList<StateRecorder, Acts::EndOfWorldReached>;
+  using PropagatorOptions = Propagator::Options<ActorList>;
 
   Navigator::Config navCfg;
   navCfg.detector = detector.get();
diff --git a/Tests/UnitTests/Core/Propagator/DirectNavigatorTests.cpp b/Tests/UnitTests/Core/Propagator/DirectNavigatorTests.cpp
index 2ca796a9d23..44a5f76b09c 100644
--- a/Tests/UnitTests/Core/Propagator/DirectNavigatorTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/DirectNavigatorTests.cpp
@@ -16,8 +16,7 @@
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/MagneticField/ConstantBField.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/DirectNavigator.hpp"
 #include "Acts/Propagator/EigenStepper.hpp"
 #include "Acts/Propagator/MaterialInteractor.hpp"
@@ -107,19 +106,18 @@ void runTest(const rpropagator_t& rprop, const dpropagator_t& dprop, double pT,
   using EndOfWorld = EndOfWorldReached;
 
   // Action list and abort list
-  using RefereceActionList = ActionList<MaterialInteractor, SurfaceCollector<>>;
-  using ReferenceAbortList = AbortList<EndOfWorld>;
+  using RefereceActorList =
+      ActorList<MaterialInteractor, SurfaceCollector<>, EndOfWorld>;
 
   // Options definition
-  using Options = typename rpropagator_t::template Options<RefereceActionList,
-                                                           ReferenceAbortList>;
+  using Options = typename rpropagator_t::template Options<RefereceActorList>;
   Options pOptions(tgContext, mfContext);
   if (oversteppingTest) {
     pOptions.stepping.maxStepSize = oversteppingMaxStepSize;
   }
 
   // Surface collector configuration
-  auto& sCollector = pOptions.actionList.template get<SurfaceCollector<>>();
+  auto& sCollector = pOptions.actorList.template get<SurfaceCollector<>>();
   sCollector.selector.selectSensitive = true;
   sCollector.selector.selectMaterial = true;
 
@@ -141,16 +139,16 @@ void runTest(const rpropagator_t& rprop, const dpropagator_t& dprop, double pT,
     }
 
     // Action list for direct navigator with its initializer
-    using DirectActionList = ActionList<MaterialInteractor, SurfaceCollector<>>;
+    using DirectActorList = ActorList<MaterialInteractor, SurfaceCollector<>>;
 
     // Direct options definition
     using DirectOptions =
-        typename dpropagator_t::template Options<DirectActionList, AbortList<>>;
+        typename dpropagator_t::template Options<DirectActorList>;
     DirectOptions dOptions(tgContext, mfContext);
     // Set the surface sequence
     dOptions.navigation.surfaces = surfaceSequence;
     // Surface collector configuration
-    auto& dCollector = dOptions.actionList.template get<SurfaceCollector<>>();
+    auto& dCollector = dOptions.actorList.template get<SurfaceCollector<>>();
     dCollector.selector.selectSensitive = true;
     dCollector.selector.selectMaterial = true;
 
diff --git a/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp b/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp
index dbf6b7b8ad4..af247952dbf 100644
--- a/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp
@@ -31,8 +31,7 @@
 #include "Acts/Material/HomogeneousSurfaceMaterial.hpp"
 #include "Acts/Material/HomogeneousVolumeMaterial.hpp"
 #include "Acts/Material/MaterialSlab.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/ConstrainedStep.hpp"
 #include "Acts/Propagator/DefaultExtension.hpp"
 #include "Acts/Propagator/DenseEnvironmentExtension.hpp"
@@ -117,8 +116,10 @@ struct EndOfWorld {
   /// Maximum value in x-direction of the detector
   double maxX = 1_m;
 
-  /// @brief Constructor
-  EndOfWorld() = default;
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  void act(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+           const navigator_t& /*navigator*/, const Logger& /*logger*/) const {}
 
   /// @brief Main call operator for the abort operation
   ///
@@ -133,9 +134,8 @@ struct EndOfWorld {
   /// @return Boolean statement if the particle is still in the detector
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& /*navigator*/,
-                  const Logger& /*logger*/) const {
+  bool check(propagator_state_t& state, const stepper_t& stepper,
+             const navigator_t& /*navigator*/, const Logger& /*logger*/) const {
     const double tolerance = state.options.surfaceTolerance;
     if (maxX - std::abs(stepper.position(state.stepping).x()) <= tolerance ||
         std::abs(stepper.position(state.stepping).y()) >= 0.5_m ||
@@ -175,12 +175,20 @@ struct StepCollector {
   /// @param [out] result Struct which is filled with the data
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& /*navigator*/, result_type& result,
-                  const Logger& /*logger*/) const {
+  void act(propagator_state_t& state, const stepper_t& stepper,
+           const navigator_t& /*navigator*/, result_type& result,
+           const Logger& /*logger*/) const {
     result.position.push_back(stepper.position(state.stepping));
     result.momentum.push_back(stepper.momentum(state.stepping));
   }
+
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+             const navigator_t& /*navigator*/, result_type& /*result*/,
+             const Logger& /*logger*/) const {
+    return false;
+  }
 };
 
 /// These tests are aiming to test whether the state setup is working properly
@@ -590,7 +598,7 @@ BOOST_AUTO_TEST_CASE(step_extension_vacuum_test) {
       detail::HighestValidAuctioneer>;
   using Propagator = Propagator<Stepper, Navigator>;
   using PropagatorOptions =
-      Propagator::Options<ActionList<StepCollector>, AbortList<EndOfWorld>>;
+      Propagator::Options<ActorList<StepCollector, EndOfWorld>>;
 
   // Set options for propagator
   PropagatorOptions propOpts(tgContext, mfContext);
@@ -624,7 +632,7 @@ BOOST_AUTO_TEST_CASE(step_extension_vacuum_test) {
       detail::HighestValidAuctioneer>;
   using DefPropagator = Acts::Propagator<DefStepper, Navigator>;
   using DefPropagatorOptions =
-      DefPropagator::Options<ActionList<StepCollector>, AbortList<EndOfWorld>>;
+      DefPropagator::Options<ActorList<StepCollector, EndOfWorld>>;
 
   // Set options for propagator
   DefPropagatorOptions propOptsDef(tgContext, mfContext);
@@ -689,7 +697,7 @@ BOOST_AUTO_TEST_CASE(step_extension_material_test) {
       detail::HighestValidAuctioneer>;
   using Propagator = Propagator<Stepper, Navigator>;
   using PropagatorOptions =
-      Propagator::Options<ActionList<StepCollector>, AbortList<EndOfWorld>>;
+      Propagator::Options<ActorList<StepCollector, EndOfWorld>>;
 
   // Set options for propagator
   PropagatorOptions propOpts(tgContext, mfContext);
@@ -732,8 +740,7 @@ BOOST_AUTO_TEST_CASE(step_extension_material_test) {
                    detail::HighestValidAuctioneer>;
   using DensePropagator = Acts::Propagator<DenseStepper, Navigator>;
   using DensePropagatorOptions =
-      DensePropagator::Options<ActionList<StepCollector>,
-                               AbortList<EndOfWorld>>;
+      DensePropagator::Options<ActorList<StepCollector, EndOfWorld>>;
 
   // Rebuild and check the choice of extension
   // Set options for propagator
@@ -839,11 +846,11 @@ BOOST_AUTO_TEST_CASE(step_extension_vacmatvac_test) {
       detail::HighestValidAuctioneer>;
   using Propagator = Acts::Propagator<Stepper, Navigator>;
   using PropagatorOptions =
-      Propagator::Options<ActionList<StepCollector>, AbortList<EndOfWorld>>;
+      Propagator::Options<ActorList<StepCollector, EndOfWorld>>;
 
   // Set options for propagator
   PropagatorOptions propOpts(tgContext, mfContext);
-  propOpts.abortList.get<EndOfWorld>().maxX = 3_m;
+  propOpts.actorList.get<EndOfWorld>().maxX = 3_m;
   propOpts.maxSteps = 1000;
   propOpts.stepping.maxStepSize = 1.5_m;
 
@@ -893,10 +900,10 @@ BOOST_AUTO_TEST_CASE(step_extension_vacmatvac_test) {
   using DefStepper = EigenStepper<StepperExtensionList<DefaultExtension>>;
   using DefPropagator = Acts::Propagator<DefStepper, Navigator>;
   using DefPropagatorOptions =
-      DefPropagator::Options<ActionList<StepCollector>, AbortList<EndOfWorld>>;
+      DefPropagator::Options<ActorList<StepCollector, EndOfWorld>>;
 
   DefPropagatorOptions propOptsDef(tgContext, mfContext);
-  propOptsDef.abortList.get<EndOfWorld>().maxX = 3_m;
+  propOptsDef.actorList.get<EndOfWorld>().maxX = 3_m;
   propOptsDef.maxSteps = 1000;
   propOptsDef.stepping.maxStepSize = 1.5_m;
 
@@ -944,12 +951,11 @@ BOOST_AUTO_TEST_CASE(step_extension_vacmatvac_test) {
       StepperExtensionList<DefaultExtension, DenseEnvironmentExtension>>;
   using DensePropagator = Acts::Propagator<DenseStepper, Navigator>;
   using DensePropagatorOptions =
-      DensePropagator::Options<ActionList<StepCollector>,
-                               AbortList<EndOfWorld>>;
+      DensePropagator::Options<ActorList<StepCollector, EndOfWorld>>;
 
   // Set options for propagator
   DensePropagatorOptions propOptsDense(tgContext, mfContext);
-  propOptsDense.abortList.get<EndOfWorld>().maxX = 3_m;
+  propOptsDense.actorList.get<EndOfWorld>().maxX = 3_m;
   propOptsDense.maxSteps = 1000;
   propOptsDense.stepping.maxStepSize = 1.5_m;
 
@@ -1075,13 +1081,12 @@ BOOST_AUTO_TEST_CASE(step_extension_trackercalomdt_test) {
       StepperExtensionList<DefaultExtension, DenseEnvironmentExtension>,
       detail::HighestValidAuctioneer>;
   using Propagator = Acts::Propagator<Stepper, Navigator>;
-  using PropagatorOptions =
-      Propagator::Options<ActionList<StepCollector, MaterialInteractor>,
-                          AbortList<EndOfWorld>>;
+  using PropagatorOptions = Propagator::Options<
+      ActorList<StepCollector, MaterialInteractor, EndOfWorld>>;
 
   // Set options for propagator
   PropagatorOptions propOpts(tgContext, mfContext);
-  propOpts.abortList.get<EndOfWorld>().maxX = 3._m;
+  propOpts.actorList.get<EndOfWorld>().maxX = 3._m;
   propOpts.maxSteps = 10000;
 
   // Build stepper and propagator
diff --git a/Tests/UnitTests/Core/Propagator/ExtrapolatorTests.cpp b/Tests/UnitTests/Core/Propagator/ExtrapolatorTests.cpp
index e20cc7430ba..a49faf6c499 100644
--- a/Tests/UnitTests/Core/Propagator/ExtrapolatorTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/ExtrapolatorTests.cpp
@@ -18,7 +18,7 @@
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/MagneticField/ConstantBField.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/EigenStepper.hpp"
 #include "Acts/Propagator/MaterialInteractor.hpp"
 #include "Acts/Propagator/Navigator.hpp"
@@ -157,8 +157,8 @@ BOOST_DATA_TEST_CASE(
   // A PlaneSelector for the SurfaceCollector
   using PlaneCollector = SurfaceCollector<PlaneSelector>;
 
-  EigenPropagatorType::Options<ActionList<PlaneCollector>> options(tgContext,
-                                                                   mfContext);
+  EigenPropagatorType::Options<ActorList<PlaneCollector>> options(tgContext,
+                                                                  mfContext);
 
   options.stepping.maxStepSize = 10_cm;
   options.pathLimit = 25_cm;
@@ -220,7 +220,7 @@ BOOST_DATA_TEST_CASE(
   CurvilinearTrackParameters start(Vector4(0, 0, 0, 0), phi, theta, q / p, cov,
                                    ParticleHypothesis::pion());
 
-  EigenPropagatorType::Options<ActionList<MaterialInteractor>> options(
+  EigenPropagatorType::Options<ActorList<MaterialInteractor>> options(
       tgContext, mfContext);
   options.stepping.maxStepSize = 25_cm;
   options.pathLimit = 25_cm;
@@ -268,7 +268,7 @@ BOOST_DATA_TEST_CASE(
                                    ParticleHypothesis::pion());
 
   // Action list and abort list
-  EigenPropagatorType::Options<ActionList<MaterialInteractor>> options(
+  EigenPropagatorType::Options<ActorList<MaterialInteractor>> options(
       tgContext, mfContext);
   options.stepping.maxStepSize = 25_cm;
   options.pathLimit = 1500_mm;
diff --git a/Tests/UnitTests/Core/Propagator/KalmanExtrapolatorTests.cpp b/Tests/UnitTests/Core/Propagator/KalmanExtrapolatorTests.cpp
index a41cce01297..37198ae3aa4 100644
--- a/Tests/UnitTests/Core/Propagator/KalmanExtrapolatorTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/KalmanExtrapolatorTests.cpp
@@ -17,8 +17,7 @@
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/MagneticField/ConstantBField.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/EigenStepper.hpp"
 #include "Acts/Propagator/Navigator.hpp"
 #include "Acts/Propagator/Propagator.hpp"
@@ -78,9 +77,9 @@ struct StepWiseActor {
   /// @param result is the mutable result state object
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& navigator, result_type& result,
-                  const Logger& /*logger*/) const {
+  void act(propagator_state_t& state, const stepper_t& stepper,
+           const navigator_t& navigator, result_type& result,
+           const Logger& /*logger*/) const {
     // Listen to the surface and create bound state where necessary
     auto surface = navigator.currentSurface(state.navigation);
     if (surface && surface->associatedDetectorElement()) {
@@ -99,6 +98,14 @@ struct StepWiseActor {
       result.finalized = true;
     }
   }
+
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+             const navigator_t& /*navigator*/, result_type& /*result*/,
+             const Logger& /*logger*/) const {
+    return false;
+  }
 };
 
 ///
@@ -135,15 +142,14 @@ BOOST_AUTO_TEST_CASE(kalman_extrapolator) {
 
   // Create the ActionList and AbortList
   using StepWiseResult = StepWiseActor::result_type;
-  using StepWiseActors = ActionList<StepWiseActor>;
-  using Aborters = AbortList<EndOfWorldReached>;
+  using StepWiseActors = ActorList<StepWiseActor, EndOfWorldReached>;
 
   // Create some options
-  using StepWiseOptions = Propagator::Options<StepWiseActors, Aborters>;
+  using StepWiseOptions = Propagator::Options<StepWiseActors>;
   StepWiseOptions swOptions(tgContext, mfContext);
 
-  using PlainActors = ActionList<>;
-  using PlainOptions = Propagator::Options<PlainActors, Aborters>;
+  using PlainActors = ActorList<>;
+  using PlainOptions = Propagator::Options<PlainActors>;
   PlainOptions pOptions(tgContext, mfContext);
 
   // Run the standard propagation
diff --git a/Tests/UnitTests/Core/Propagator/LoopProtectionTests.cpp b/Tests/UnitTests/Core/Propagator/LoopProtectionTests.cpp
index c0a2a35d214..06ba5e8acee 100644
--- a/Tests/UnitTests/Core/Propagator/LoopProtectionTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/LoopProtectionTests.cpp
@@ -18,8 +18,7 @@
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/MagneticField/ConstantBField.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/EigenStepper.hpp"
 #include "Acts/Propagator/Propagator.hpp"
 #include "Acts/Propagator/StandardAborters.hpp"
@@ -103,7 +102,7 @@ struct Options {
   int debugPfxWidth = 30;
 
   /// Contains: target aborters
-  AbortList<PathLimitReached> abortList;
+  ActorList<PathLimitReached> abortList;
 
   const Acts::Logger& logger = Acts::getDummyLogger();
 };
@@ -198,7 +197,7 @@ BOOST_DATA_TEST_CASE(
   CurvilinearTrackParameters start(Vector4(0, 0, 0, 42), phi, theta, q / p,
                                    std::nullopt, ParticleHypothesis::pion());
 
-  using PropagatorOptions = EigenPropagator::Options<ActionList<>, AbortList<>>;
+  using PropagatorOptions = EigenPropagator::Options<ActorList<>>;
   PropagatorOptions options(tgContext, mfContext);
   options.maxSteps = 1e6;
   const auto& result = epropagator.propagate(start, options).value();
diff --git a/Tests/UnitTests/Core/Propagator/MaterialCollectionTests.cpp b/Tests/UnitTests/Core/Propagator/MaterialCollectionTests.cpp
index a1bce8d77dc..20594d0fed0 100644
--- a/Tests/UnitTests/Core/Propagator/MaterialCollectionTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/MaterialCollectionTests.cpp
@@ -19,8 +19,7 @@
 #include "Acts/Geometry/GeometryIdentifier.hpp"
 #include "Acts/MagneticField/ConstantBField.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/EigenStepper.hpp"
 #include "Acts/Propagator/MaterialInteractor.hpp"
 #include "Acts/Propagator/Navigator.hpp"
@@ -86,18 +85,16 @@ template <typename propagator_t>
 void runTest(const propagator_t& prop,
              const CurvilinearTrackParameters& start) {
   // Action list and abort list
-  using ActionListType = ActionList<MaterialInteractor>;
-  using AbortListType = AbortList<>;
+  using ActorList = ActorList<MaterialInteractor>;
 
-  using Options =
-      typename propagator_t::template Options<ActionListType, AbortListType>;
+  using Options = typename propagator_t::template Options<ActorList>;
   Options fwdOptions(tgContext, mfContext);
   fwdOptions.stepping.maxStepSize = 25_cm;
   fwdOptions.pathLimit = 25_cm;
 
   // get the material collector and configure it
   auto& fwdMaterialInteractor =
-      fwdOptions.actionList.template get<MaterialInteractor>();
+      fwdOptions.actorList.template get<MaterialInteractor>();
   fwdMaterialInteractor.recordInteractions = true;
   fwdMaterialInteractor.energyLoss = false;
   fwdMaterialInteractor.multipleScattering = false;
@@ -141,7 +138,7 @@ void runTest(const propagator_t& prop,
 
   // get the material collector and configure it
   auto& bwdMaterialInteractor =
-      bwdOptions.actionList.template get<MaterialInteractor>();
+      bwdOptions.actorList.template get<MaterialInteractor>();
   bwdMaterialInteractor.recordInteractions = true;
   bwdMaterialInteractor.energyLoss = false;
   bwdMaterialInteractor.multipleScattering = false;
@@ -198,7 +195,7 @@ void runTest(const propagator_t& prop,
 
   // get the material collector and configure it
   auto& fwdStepMaterialInteractor =
-      fwdStepOptions.actionList.template get<MaterialInteractor>();
+      fwdStepOptions.actorList.template get<MaterialInteractor>();
   fwdStepMaterialInteractor.recordInteractions = true;
   fwdStepMaterialInteractor.energyLoss = false;
   fwdStepMaterialInteractor.multipleScattering = false;
@@ -272,7 +269,7 @@ void runTest(const propagator_t& prop,
 
   // get the material collector and configure it
   auto& bwdStepMaterialInteractor =
-      bwdStepOptions.actionList.template get<MaterialInteractor>();
+      bwdStepOptions.actorList.template get<MaterialInteractor>();
   bwdStepMaterialInteractor.recordInteractions = true;
   bwdStepMaterialInteractor.multipleScattering = false;
   bwdStepMaterialInteractor.energyLoss = false;
@@ -338,7 +335,7 @@ void runTest(const propagator_t& prop,
   // Test the material affects the covariance into the right direction
   // get the material collector and configure it
   auto& covfwdMaterialInteractor =
-      fwdOptions.actionList.template get<MaterialInteractor>();
+      fwdOptions.actorList.template get<MaterialInteractor>();
   covfwdMaterialInteractor.recordInteractions = false;
   covfwdMaterialInteractor.energyLoss = true;
   covfwdMaterialInteractor.multipleScattering = true;
diff --git a/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp b/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp
index dad3439cba7..ca1a75e4236 100644
--- a/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp
@@ -20,8 +20,7 @@
 #include "Acts/Geometry/GeometryIdentifier.hpp"
 #include "Acts/MagneticField/ConstantBField.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/ConstrainedStep.hpp"
 #include "Acts/Propagator/DenseEnvironmentExtension.hpp"
 #include "Acts/Propagator/EigenStepper.hpp"
@@ -106,9 +105,9 @@ struct SurfaceObserver {
 
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const navigator_t& /*navigator*/, result_type& result,
-                  const Logger& /*logger*/) const {
+  void act(propagator_state_t& state, const stepper_t& stepper,
+           const navigator_t& /*navigator*/, result_type& result,
+           const Logger& /*logger*/) const {
     if (surface && !result.surfaces_passed) {
       // calculate the distance to the surface
       const double distance =
@@ -130,6 +129,14 @@ struct SurfaceObserver {
       }
     }
   }
+
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+             const navigator_t& /*navigator*/, result_type& /*result*/,
+             const Logger& /*logger*/) const {
+    return false;
+  }
 };
 
 // Global definitions
@@ -153,16 +160,12 @@ const int ntests = 5;
 
 // This tests the Options
 BOOST_AUTO_TEST_CASE(PropagatorOptions_) {
-  using null_optionsType = EigenPropagatorType::Options<>;
-  null_optionsType null_options(tgContext, mfContext);
-  // todo write null options test
-
-  using ActionListType = ActionList<PerpendicularMeasure>;
-  using AbortConditionsType = AbortList<>;
-
-  using optionsType = PropagatorOptions<ActionListType, AbortConditionsType>;
+  using NullOptionsType = EigenPropagatorType::Options<>;
+  NullOptionsType null_options(tgContext, mfContext);
 
-  optionsType options(tgContext, mfContext);
+  using ActorList = ActorList<PerpendicularMeasure>;
+  using OptionsType = EigenPropagatorType::Options<ActorList>;
+  OptionsType options(tgContext, mfContext);
 }
 
 BOOST_DATA_TEST_CASE(
@@ -191,18 +194,16 @@ BOOST_DATA_TEST_CASE(
   (void)index;
 
   using CylinderObserver = SurfaceObserver<CylinderSurface>;
-  using ActionListType = ActionList<CylinderObserver>;
-  using AbortConditionsType = AbortList<>;
+  using ActorList = ActorList<CylinderObserver>;
 
   // setup propagation options
-  EigenPropagatorType::Options<ActionListType, AbortConditionsType> options(
-      tgContext, mfContext);
+  EigenPropagatorType::Options<ActorList> options(tgContext, mfContext);
 
   options.pathLimit = 20_m;
   options.stepping.maxStepSize = 1_cm;
 
   // set the surface to be passed by
-  options.actionList.get<CylinderObserver>().surface = mSurface.get();
+  options.actorList.get<CylinderObserver>().surface = mSurface.get();
 
   using so_result = typename CylinderObserver::result_type;
 
diff --git a/Tests/UnitTests/Core/Propagator/SympyStepperTests.cpp b/Tests/UnitTests/Core/Propagator/SympyStepperTests.cpp
index 1ea875e5735..75a1a5a30b7 100644
--- a/Tests/UnitTests/Core/Propagator/SympyStepperTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/SympyStepperTests.cpp
@@ -31,8 +31,7 @@
 #include "Acts/Material/HomogeneousSurfaceMaterial.hpp"
 #include "Acts/Material/HomogeneousVolumeMaterial.hpp"
 #include "Acts/Material/MaterialSlab.hpp"
-#include "Acts/Propagator/AbortList.hpp"
-#include "Acts/Propagator/ActionList.hpp"
+#include "Acts/Propagator/ActorList.hpp"
 #include "Acts/Propagator/ConstrainedStep.hpp"
 #include "Acts/Propagator/DefaultExtension.hpp"
 #include "Acts/Propagator/DenseEnvironmentExtension.hpp"
diff --git a/Tests/UnitTests/Fatras/Kernel/SimulationActorTests.cpp b/Tests/UnitTests/Fatras/Kernel/SimulationActorTests.cpp
index ee463e5a729..48a145d1c11 100644
--- a/Tests/UnitTests/Fatras/Kernel/SimulationActorTests.cpp
+++ b/Tests/UnitTests/Fatras/Kernel/SimulationActorTests.cpp
@@ -233,7 +233,8 @@ BOOST_AUTO_TEST_CASE(HitsOnEmptySurface) {
   BOOST_CHECK_EQUAL(f.actor.initialParticle.energy(), f.e);
 
   // call.actor: surface selection -> one hit, no material -> no secondary
-  f.actor(f.state, f.stepper, f.navigator, f.result, Acts::getDummyLogger());
+  f.actor.act(f.state, f.stepper, f.navigator, f.result,
+              Acts::getDummyLogger());
   BOOST_CHECK(f.result.isAlive);
   CHECK_CLOSE_REL(f.result.particle.energy(), f.e, tol);
   BOOST_CHECK_EQUAL(f.result.generatedParticles.size(), 0u);
@@ -258,7 +259,8 @@ BOOST_AUTO_TEST_CASE(HitsOnEmptySurface) {
   BOOST_CHECK_EQUAL(f.state.stepping.p, f.result.particle.absoluteMomentum());
 
   // call.actor again: one more hit, still no secondary
-  f.actor(f.state, f.stepper, f.navigator, f.result, Acts::getDummyLogger());
+  f.actor.act(f.state, f.stepper, f.navigator, f.result,
+              Acts::getDummyLogger());
   BOOST_CHECK(f.result.isAlive);
   CHECK_CLOSE_REL(f.result.particle.energy(), f.e, tol);
   BOOST_CHECK_EQUAL(f.result.generatedParticles.size(), 0u);
@@ -304,7 +306,8 @@ BOOST_AUTO_TEST_CASE(HitsOnMaterialSurface) {
   BOOST_CHECK_EQUAL(f.actor.initialParticle.energy(), f.e);
 
   // call.actor: surface selection -> one hit, material -> one secondary
-  f.actor(f.state, f.stepper, f.navigator, f.result, Acts::getDummyLogger());
+  f.actor.act(f.state, f.stepper, f.navigator, f.result,
+              Acts::getDummyLogger());
   BOOST_CHECK(f.result.isAlive);
   CHECK_CLOSE_REL(f.result.particle.energy(), f.e - 125_MeV, tol);
   BOOST_CHECK_EQUAL(f.result.generatedParticles.size(), 1u);
@@ -331,7 +334,8 @@ BOOST_AUTO_TEST_CASE(HitsOnMaterialSurface) {
                   tol);
 
   // call.actor again: one more hit, one more secondary
-  f.actor(f.state, f.stepper, f.navigator, f.result, Acts::getDummyLogger());
+  f.actor.act(f.state, f.stepper, f.navigator, f.result,
+              Acts::getDummyLogger());
   BOOST_CHECK(f.result.isAlive);
   CHECK_CLOSE_REL(f.result.particle.energy(), f.e - 250_MeV, tol);
   BOOST_CHECK_EQUAL(f.result.generatedParticles.size(), 2u);
@@ -377,7 +381,8 @@ BOOST_AUTO_TEST_CASE(NoHitsEmptySurface) {
   BOOST_CHECK_EQUAL(f.actor.initialParticle.energy(), f.e);
 
   // call.actor: no surface sel. -> no hit, no material -> no secondary
-  f.actor(f.state, f.stepper, f.navigator, f.result, Acts::getDummyLogger());
+  f.actor.act(f.state, f.stepper, f.navigator, f.result,
+              Acts::getDummyLogger());
   BOOST_CHECK(f.result.isAlive);
   CHECK_CLOSE_REL(f.result.particle.energy(), f.e, tol);
   BOOST_CHECK_EQUAL(f.result.generatedParticles.size(), 0u);
@@ -402,7 +407,8 @@ BOOST_AUTO_TEST_CASE(NoHitsEmptySurface) {
   BOOST_CHECK_EQUAL(f.state.stepping.p, f.result.particle.absoluteMomentum());
 
   // call.actor again: no hit, still no secondary
-  f.actor(f.state, f.stepper, f.navigator, f.result, Acts::getDummyLogger());
+  f.actor.act(f.state, f.stepper, f.navigator, f.result,
+              Acts::getDummyLogger());
   BOOST_CHECK(f.result.isAlive);
   CHECK_CLOSE_REL(f.result.particle.energy(), f.e, tol);
   BOOST_CHECK_EQUAL(f.result.generatedParticles.size(), 0u);
@@ -438,7 +444,8 @@ BOOST_AUTO_TEST_CASE(NoHitsMaterialSurface) {
   Fixture<NoSurface> f(125_MeV, makeMaterialSurface());
 
   // call.actor: no surface sel. -> no hit, material -> one secondary
-  f.actor(f.state, f.stepper, f.navigator, f.result, Acts::getDummyLogger());
+  f.actor.act(f.state, f.stepper, f.navigator, f.result,
+              Acts::getDummyLogger());
   BOOST_CHECK(f.result.isAlive);
   CHECK_CLOSE_REL(f.result.particle.energy(), f.e - 125_MeV, tol);
   BOOST_CHECK_EQUAL(f.result.generatedParticles.size(), 1u);
@@ -464,7 +471,8 @@ BOOST_AUTO_TEST_CASE(NoHitsMaterialSurface) {
                   tol);
 
   // call.actor again: still no hit, one more secondary
-  f.actor(f.state, f.stepper, f.navigator, f.result, Acts::getDummyLogger());
+  f.actor.act(f.state, f.stepper, f.navigator, f.result,
+              Acts::getDummyLogger());
   BOOST_CHECK(f.result.isAlive);
   CHECK_CLOSE_REL(f.result.particle.energy(), f.e - 250_MeV, tol);
   BOOST_CHECK_EQUAL(f.result.generatedParticles.size(), 2u);
@@ -504,7 +512,8 @@ BOOST_AUTO_TEST_CASE(Decay) {
   const auto gammaInv = f.m / f.e;
 
   // first step w/ defaults leaves particle alive
-  f.actor(f.state, f.stepper, f.navigator, f.result, Acts::getDummyLogger());
+  f.actor.act(f.state, f.stepper, f.navigator, f.result,
+              Acts::getDummyLogger());
   BOOST_CHECK(f.result.isAlive);
   BOOST_CHECK_EQUAL(f.result.particle.particleId(), f.pid);
   BOOST_CHECK_EQUAL(f.result.particle.process(), f.proc);
@@ -516,7 +525,8 @@ BOOST_AUTO_TEST_CASE(Decay) {
 
   // second step w/ defaults increases proper time
   f.state.stepping.time += 1_ns;
-  f.actor(f.state, f.stepper, f.navigator, f.result, Acts::getDummyLogger());
+  f.actor.act(f.state, f.stepper, f.navigator, f.result,
+              Acts::getDummyLogger());
   BOOST_CHECK(f.result.isAlive);
   BOOST_CHECK_EQUAL(f.result.particle.particleId(), f.pid);
   BOOST_CHECK_EQUAL(f.result.particle.process(), f.proc);
@@ -529,7 +539,8 @@ BOOST_AUTO_TEST_CASE(Decay) {
   // third step w/ proper time limit decays the particle
   f.state.stepping.time += 1_ns;
   f.result.properTimeLimit = f.result.particle.properTime() + gammaInv * 0.5_ns;
-  f.actor(f.state, f.stepper, f.navigator, f.result, Acts::getDummyLogger());
+  f.actor.act(f.state, f.stepper, f.navigator, f.result,
+              Acts::getDummyLogger());
   BOOST_CHECK(!f.result.isAlive);
   BOOST_CHECK_EQUAL(f.result.particle.particleId(), f.pid);
   BOOST_CHECK_EQUAL(f.result.particle.process(), f.proc);
diff --git a/docs/core/propagation.md b/docs/core/propagation.md
index 175278a0157..729e939ceb8 100644
--- a/docs/core/propagation.md
+++ b/docs/core/propagation.md
@@ -52,7 +52,7 @@ The actors and aborters are instantiated with the options and can be accessed wi
 
 ```cpp
 auto options = MyOptions();
-options.actionList.get<MyActor1>().foo = bar;
+options.actorList.get<MyActor1>().foo = bar;
 options.maxStepSize = 100;
 ```
 

From 494d8fc6d09da15b9b4dd1a249c5d274a4c7f4e7 Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Wed, 28 Aug 2024 21:23:06 +0200
Subject: [PATCH 02/15] add missing files

---
 Core/include/Acts/Propagator/ActorList.hpp    | 130 ++++++++++++++++
 .../detail/actor_list_implementation.hpp      | 146 ++++++++++++++++++
 2 files changed, 276 insertions(+)
 create mode 100644 Core/include/Acts/Propagator/ActorList.hpp
 create mode 100644 Core/include/Acts/Propagator/detail/actor_list_implementation.hpp

diff --git a/Core/include/Acts/Propagator/ActorList.hpp b/Core/include/Acts/Propagator/ActorList.hpp
new file mode 100644
index 00000000000..39f74e8e2d1
--- /dev/null
+++ b/Core/include/Acts/Propagator/ActorList.hpp
@@ -0,0 +1,130 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2016-2024 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 "Acts/Propagator/detail/actor_list_implementation.hpp"
+#include "Acts/Utilities/detail/Extendable.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;
+
+namespace Acts {
+
+/// @brief ActorList implementation to be used with the propagator
+///
+/// This is the ActorList struct that is used in the propagator
+/// to define a list of different actors_t that are each
+/// executed during the stepping procedure
+template <typename... actors_t>
+struct ActorList : public detail::Extendable<actors_t...> {
+ private:
+  static_assert(!detail::has_duplicates_v<actors_t...>,
+                "same action type specified several times");
+
+  using detail::Extendable<actors_t...>::tuple;
+
+ public:
+  /// @cond
+  // This uses the type collector and unpacks using the `R` meta function
+  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;
+  /// @endcond
+
+  using detail::Extendable<actors_t...>::get;
+
+  /// Default constructor
+  ActorList() = default;
+
+  /// Default copy constructor
+  ///
+  /// @param actors The source action list
+  ActorList(const ActorList<actors_t...>& actors) = default;
+
+  /// Default move constructor
+  ///
+  /// @param actors The source action list
+  ActorList(ActorList<actors_t...>&& actors) = default;
+
+  /// Default move assignment operator
+  ///
+  /// @param actors The source action list
+  ActorList<actors_t...>& operator=(const ActorList<actors_t...>& actors) =
+      default;
+
+  /// Default move assignment operator
+  ///
+  /// @param actors The source action list
+  ActorList<actors_t...>& operator=(ActorList<actors_t...>&& actors) = default;
+
+  /// Constructor from tuple
+  ///
+  /// @param actors Source extensions tuple
+  ActorList(const std::tuple<actors_t...>& actors)
+      : detail::Extendable<actors_t...>(actors) {}
+
+  /// Constructor from tuple move
+  ///
+  /// @param actors Source extensions tuple
+  ActorList(std::tuple<actors_t...>&& actors)
+      : detail::Extendable<actors_t...>(std::move(actors)) {}
+
+  /// Append new entries and return a new condition
+  template <typename... appendices_t>
+  ActorList<actors_t..., appendices_t...> append(appendices_t... aps) const {
+    auto catTuple =
+        std::tuple_cat(tuple(), std::tuple<appendices_t...>(aps...));
+    return ActorList<actors_t..., appendices_t...>(std::move(catTuple));
+  }
+
+  /// Act call which broadcasts the call to the tuple() members of the list
+  ///
+  /// @tparam propagator_state_t is the state type of the propagator
+  /// @tparam stepper_t Type of the stepper used for the propagation
+  /// @tparam navigator_t Type of the navigator used for the propagation
+  ///
+  /// @param [in,out] state This is the propagator state object
+  /// @param [in] stepper The stepper in use
+  /// @param [in] navigator The navigator in use
+  /// @param [in] args The arguments to be passed to the actions
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t, typename... Args>
+  void act(propagator_state_t& state, const stepper_t& stepper,
+           const navigator_t& navigator, Args&&... args) const {
+    using impl = detail::actor_list_impl<actors_t...>;
+    impl::act(tuple(), state, stepper, navigator, std::forward<Args>(args)...);
+  }
+
+  /// Check call which broadcasts the call to the tuple() members of the list
+  ///
+  /// @tparam propagator_state_t is the state type of the propagator
+  /// @tparam stepper_t Type of the stepper
+  /// @tparam navigator_t Type of the navigator
+  ///
+  /// @param [in,out] state is the state object from the propagator
+  /// @param [in] stepper Stepper used for the propagation
+  /// @param [in] navigator Navigator used for the propagation
+  /// @param [in] args are the arguments to be passed to the aborters
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t, typename... Args>
+  bool check(propagator_state_t& state, const stepper_t& stepper,
+             const navigator_t& navigator, Args&&... args) const {
+    using impl = detail::actor_list_impl<actors_t...>;
+    return impl::check(tuple(), state, stepper, navigator,
+                       std::forward<Args>(args)...);
+  }
+};
+
+}  // namespace Acts
diff --git a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
new file mode 100644
index 00000000000..b31d235946c
--- /dev/null
+++ b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
@@ -0,0 +1,146 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2018-2024 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 "Acts/Utilities/detail/MPL/type_collector.hpp"
+
+#include <utility>
+
+namespace Acts::detail {
+
+namespace {
+
+/// The action caller struct, it's called with the the right result object,
+/// which is taken out from the result tuple
+template <bool has_result = true>
+struct actor_caller {
+  template <typename actor_t, typename propagator_state_t, typename stepper_t,
+            typename navigator_t, typename... Args>
+  static void act(const actor_t& actor, propagator_state_t& state,
+                  const stepper_t& stepper, const navigator_t& navigator,
+                  Args&&... args) {
+    actor.act(state, stepper, navigator,
+              state.template get<detail::result_type_t<actor_t>>(),
+              std::forward<Args>(args)...);
+  }
+
+  template <typename actor_t, typename propagator_state_t, typename stepper_t,
+            typename navigator_t, typename... Args>
+  static bool check(const actor_t& actor, propagator_state_t& state,
+                    const stepper_t& stepper, const navigator_t& navigator,
+                    Args&&... args) {
+    return actor.check(state, stepper, navigator,
+                       state.template get<detail::result_type_t<actor_t>>(),
+                       std::forward<Args>(args)...);
+  }
+};
+
+/// The action caller struct, without result object
+template <>
+struct actor_caller<false> {
+  template <typename actor_t, typename propagator_state_t, typename stepper_t,
+            typename navigator_t, typename... Args>
+  static void act(const actor_t& actor, propagator_state_t& state,
+                  const stepper_t& stepper, const navigator_t& navigator,
+                  Args&&... args) {
+    actor.act(state, stepper, navigator, std::forward<Args>(args)...);
+  }
+
+  template <typename actor_t, typename propagator_state_t, typename stepper_t,
+            typename navigator_t, typename... Args>
+  static bool check(const actor_t& actor, propagator_state_t& state,
+                    const stepper_t& stepper, const navigator_t& navigator,
+                    Args&&... args) {
+    return actor.check(state, stepper, navigator, std::forward<Args>(args)...);
+  }
+};
+}  // end of anonymous namespace
+
+/// The dummy list call implementation
+template <typename... actors>
+struct actor_list_impl;
+
+/// The action list call implementation
+/// - it calls 'action' on the current entry of the tuple
+/// - then broadcasts the action call to the remaining tuple
+template <typename first, typename... others>
+struct actor_list_impl<first, others...> {
+  template <typename T, typename propagator_state_t, typename stepper_t,
+            typename navigator_t, typename... Args>
+  static void act(const T& actors_tuple, propagator_state_t& state,
+                  const stepper_t& stepper, const navigator_t& navigator,
+                  Args&&... args) {
+    constexpr bool has_result = has_result_type_v<first>;
+    const auto& this_actor = std::get<first>(actors_tuple);
+    actor_caller<has_result>::act(this_actor, state, stepper, navigator,
+                                  args...);
+    actor_list_impl<others...>::act(actors_tuple, state, stepper, navigator,
+                                    args...);
+  }
+
+  template <typename T, typename propagator_state_t, typename stepper_t,
+            typename navigator_t, typename... Args>
+  static bool check(const T& actors_tuple, propagator_state_t& state,
+                    const stepper_t& stepper, const navigator_t& navigator,
+                    Args&&... args) {
+    constexpr bool has_result = has_result_type_v<first>;
+    const auto& this_actor = std::get<first>(actors_tuple);
+    return actor_caller<has_result>::check(this_actor, state, stepper,
+                                           navigator, args...) ||
+           actor_list_impl<others...>::check(actors_tuple, state, stepper,
+                                             navigator, args...);
+  }
+};
+
+/// The action list call implementation
+/// - it calls 'action' on the last entry of the tuple
+template <typename last>
+struct actor_list_impl<last> {
+  template <typename T, typename propagator_state_t, typename stepper_t,
+            typename navigator_t, typename... Args>
+  static void act(const T& actors_tuple, propagator_state_t& state,
+                  const stepper_t& stepper, const navigator_t& navigator,
+                  Args&&... args) {
+    constexpr bool has_result = has_result_type_v<last>;
+    const auto& this_actor = std::get<last>(actors_tuple);
+    actor_caller<has_result>::act(this_actor, state, stepper, navigator,
+                                  std::forward<Args>(args)...);
+  }
+
+  template <typename T, typename propagator_state_t, typename stepper_t,
+            typename navigator_t, typename... Args>
+  static bool check(const T& actors_tuple, propagator_state_t& state,
+                    const stepper_t& stepper, const navigator_t& navigator,
+                    Args&&... args) {
+    constexpr bool has_result = has_result_type_v<last>;
+    const auto& this_actor = std::get<last>(actors_tuple);
+    return actor_caller<has_result>::check(
+        this_actor, state, stepper, navigator, std::forward<Args>(args)...);
+  }
+};
+
+/// The empty action list call implementation
+template <>
+struct actor_list_impl<> {
+  template <typename T, typename propagator_state_t, typename stepper_t,
+            typename navigator_t, typename... Args>
+  static void act(const T& /*actors_tuple*/, propagator_state_t& /*state*/,
+                  const stepper_t& /*stepper*/,
+                  const navigator_t& /*navigator*/, Args&&... /*args*/) {}
+
+  template <typename T, typename propagator_state_t, typename stepper_t,
+            typename navigator_t, typename... Args>
+  static bool check(const T& /*actors_tuple*/, propagator_state_t& /*state*/,
+                    const stepper_t& /*stepper*/,
+                    const navigator_t& /*navigator*/, Args&&... /*args*/) {
+    return false;
+  }
+};
+
+}  // namespace Acts::detail

From b649c02177ab5e5fa55598e02e5397e8c98698c9 Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Thu, 29 Aug 2024 09:54:47 +0200
Subject: [PATCH 03/15] fix

---
 Tests/UnitTests/Core/Propagator/KalmanExtrapolatorTests.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Tests/UnitTests/Core/Propagator/KalmanExtrapolatorTests.cpp b/Tests/UnitTests/Core/Propagator/KalmanExtrapolatorTests.cpp
index 37198ae3aa4..55d25709a75 100644
--- a/Tests/UnitTests/Core/Propagator/KalmanExtrapolatorTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/KalmanExtrapolatorTests.cpp
@@ -148,7 +148,7 @@ BOOST_AUTO_TEST_CASE(kalman_extrapolator) {
   using StepWiseOptions = Propagator::Options<StepWiseActors>;
   StepWiseOptions swOptions(tgContext, mfContext);
 
-  using PlainActors = ActorList<>;
+  using PlainActors = ActorList<EndOfWorldReached>;
   using PlainOptions = Propagator::Options<PlainActors>;
   PlainOptions pOptions(tgContext, mfContext);
 

From 6a268fb6c6bd7964e18b25626c3725cdc3aa69f0 Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Thu, 29 Aug 2024 14:28:01 +0200
Subject: [PATCH 04/15] concepts

---
 .../include/Acts/Propagator/ActorConcepts.hpp | 105 ++++++++++++++++++
 .../Acts/Propagator/SurfaceCollector.hpp      |   8 --
 .../detail/actor_list_implementation.hpp      |  91 ++++++++-------
 .../Utilities/detail/MPL/type_collector.hpp   |   3 +
 4 files changed, 153 insertions(+), 54 deletions(-)
 create mode 100644 Core/include/Acts/Propagator/ActorConcepts.hpp

diff --git a/Core/include/Acts/Propagator/ActorConcepts.hpp b/Core/include/Acts/Propagator/ActorConcepts.hpp
new file mode 100644
index 00000000000..9730228d02c
--- /dev/null
+++ b/Core/include/Acts/Propagator/ActorConcepts.hpp
@@ -0,0 +1,105 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2024 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 <concepts>
+#include <type_traits>
+#include <utility>
+
+namespace Acts {
+
+template <typename actor_t>
+concept ActorHasResult = requires { typename actor_t::result_type; };
+
+template <typename actor_t, typename propagator_state_t, typename stepper_t,
+          typename navigator_t, typename... Args>
+concept ActorHasActWithResult =
+    requires(const actor_t& a, propagator_state_t& state,
+             const stepper_t& stepper, const navigator_t& navigator,
+             typename actor_t::result_type& result, Args&&... args) {
+      {
+        a.act(state, stepper, navigator, result, std::forward<Args>(args)...)
+      } -> std::same_as<void>;
+    };
+
+template <typename actor_t, typename propagator_state_t, typename stepper_t,
+          typename navigator_t, typename... Args>
+concept ActorHasActWithoutResult = requires(
+    const actor_t& a, propagator_state_t& state, const stepper_t& stepper,
+    const navigator_t& navigator, Args&&... args) {
+  {
+    a.act(state, stepper, navigator, std::forward<Args>(args)...)
+  } -> std::same_as<void>;
+};
+
+template <typename actor_t, typename propagator_state_t, typename stepper_t,
+          typename navigator_t, typename... Args>
+concept ActorHasAct =
+    (!ActorHasResult<actor_t> &&
+     ActorHasActWithoutResult<actor_t, propagator_state_t, stepper_t,
+                              navigator_t, Args...>) ||
+    (ActorHasResult<actor_t> &&
+     ActorHasActWithResult<actor_t, propagator_state_t, stepper_t, navigator_t,
+                           Args...>);
+
+template <typename actor_t, typename propagator_state_t, typename stepper_t,
+          typename navigator_t, typename... Args>
+concept ActorHasAbortWithResult =
+    requires(const actor_t& a, propagator_state_t& state,
+             const stepper_t& stepper, const navigator_t& navigator,
+             typename actor_t::result_type& result, Args&&... args) {
+      {
+        a.check(state, stepper, navigator, result, std::forward<Args>(args)...)
+      } -> std::same_as<bool>;
+    };
+
+template <typename actor_t, typename propagator_state_t, typename stepper_t,
+          typename navigator_t, typename... Args>
+concept ActorHasAbortWithoutResult = requires(
+    const actor_t& a, propagator_state_t& state, const stepper_t& stepper,
+    const navigator_t& navigator, Args&&... args) {
+  {
+    a.check(state, stepper, navigator, std::forward<Args>(args)...)
+  } -> std::same_as<bool>;
+};
+
+template <typename actor_t, typename propagator_state_t, typename stepper_t,
+          typename navigator_t, typename... Args>
+concept ActorHasAbort =
+    (!ActorHasResult<actor_t> &&
+     ActorHasAbortWithoutResult<actor_t, propagator_state_t, stepper_t,
+                                navigator_t, Args...>) ||
+    (ActorHasResult<actor_t> &&
+     ActorHasAbortWithResult<actor_t, propagator_state_t, stepper_t,
+                             navigator_t, Args...>);
+
+template <typename actor_t, typename propagator_state_t, typename stepper_t,
+          typename navigator_t, typename... Args>
+concept ActorHasActAndAbort =
+    (!ActorHasResult<actor_t> &&
+     ActorHasActWithoutResult<actor_t, propagator_state_t, stepper_t,
+                              navigator_t, Args...> &&
+     ActorHasAbortWithoutResult<actor_t, propagator_state_t, stepper_t,
+                                navigator_t, Args...>) ||
+    (ActorHasResult<actor_t> &&
+     ActorHasActWithResult<actor_t, propagator_state_t, stepper_t, navigator_t,
+                           Args...> &&
+     ActorHasAbortWithResult<actor_t, propagator_state_t, stepper_t,
+                             navigator_t, Args...>);
+
+template <typename actor_t, typename propagator_state_t, typename stepper_t,
+          typename navigator_t, typename... Args>
+concept Actor =
+    ActorHasAct<actor_t, propagator_state_t, stepper_t, navigator_t, Args...> ||
+    ActorHasAbort<actor_t, propagator_state_t, stepper_t, navigator_t,
+                  Args...> ||
+    ActorHasActAndAbort<actor_t, propagator_state_t, stepper_t, navigator_t,
+                        Args...>;
+
+}  // namespace Acts
diff --git a/Core/include/Acts/Propagator/SurfaceCollector.hpp b/Core/include/Acts/Propagator/SurfaceCollector.hpp
index 14c22777e10..62395ae0824 100644
--- a/Core/include/Acts/Propagator/SurfaceCollector.hpp
+++ b/Core/include/Acts/Propagator/SurfaceCollector.hpp
@@ -114,14 +114,6 @@ struct SurfaceCollector {
       ACTS_VERBOSE("Collect surface  " << currentSurface->geometryId());
     }
   }
-
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-             const navigator_t& /*navigator*/, result_type& /*result*/,
-             const Logger& /*logger*/) const {
-    return false;
-  }
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
index b31d235946c..f61af5ff7fa 100644
--- a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
+++ b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "Acts/Propagator/ActorConcepts.hpp"
 #include "Acts/Utilities/detail/MPL/type_collector.hpp"
 
 #include <utility>
@@ -16,18 +17,26 @@ namespace Acts::detail {
 
 namespace {
 
-/// The action caller struct, it's called with the the right result object,
-/// which is taken out from the result tuple
-template <bool has_result = true>
 struct actor_caller {
   template <typename actor_t, typename propagator_state_t, typename stepper_t,
             typename navigator_t, typename... Args>
   static void act(const actor_t& actor, propagator_state_t& state,
                   const stepper_t& stepper, const navigator_t& navigator,
                   Args&&... args) {
-    actor.act(state, stepper, navigator,
-              state.template get<detail::result_type_t<actor_t>>(),
-              std::forward<Args>(args)...);
+    static_assert(
+        Actor<actor_t, propagator_state_t, stepper_t, navigator_t, Args...>,
+        "The actor does not fulfill the Actor concept");
+
+    if constexpr (ActorHasAct<actor_t, propagator_state_t, stepper_t,
+                              navigator_t, Args...>) {
+      if constexpr (ActorHasResult<actor_t>) {
+        actor.act(state, stepper, navigator,
+                  state.template get<detail::result_type_t<actor_t>>(),
+                  std::forward<Args>(args)...);
+      } else {
+        actor.act(state, stepper, navigator, std::forward<Args>(args)...);
+      }
+    }
   }
 
   template <typename actor_t, typename propagator_state_t, typename stepper_t,
@@ -35,31 +44,26 @@ struct actor_caller {
   static bool check(const actor_t& actor, propagator_state_t& state,
                     const stepper_t& stepper, const navigator_t& navigator,
                     Args&&... args) {
-    return actor.check(state, stepper, navigator,
-                       state.template get<detail::result_type_t<actor_t>>(),
-                       std::forward<Args>(args)...);
-  }
-};
-
-/// The action caller struct, without result object
-template <>
-struct actor_caller<false> {
-  template <typename actor_t, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static void act(const actor_t& actor, propagator_state_t& state,
-                  const stepper_t& stepper, const navigator_t& navigator,
-                  Args&&... args) {
-    actor.act(state, stepper, navigator, std::forward<Args>(args)...);
-  }
+    static_assert(
+        Actor<actor_t, propagator_state_t, stepper_t, navigator_t, Args...>,
+        "The actor does not fulfill the Actor concept");
+
+    if constexpr (ActorHasAbort<actor_t, propagator_state_t, stepper_t,
+                                navigator_t, Args...>) {
+      if constexpr (ActorHasResult<actor_t>) {
+        return actor.check(state, stepper, navigator,
+                           state.template get<detail::result_type_t<actor_t>>(),
+                           std::forward<Args>(args)...);
+      } else {
+        return actor.check(state, stepper, navigator,
+                           std::forward<Args>(args)...);
+      }
+    }
 
-  template <typename actor_t, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static bool check(const actor_t& actor, propagator_state_t& state,
-                    const stepper_t& stepper, const navigator_t& navigator,
-                    Args&&... args) {
-    return actor.check(state, stepper, navigator, std::forward<Args>(args)...);
+    return false;
   }
 };
+
 }  // end of anonymous namespace
 
 /// The dummy list call implementation
@@ -73,27 +77,24 @@ template <typename first, typename... others>
 struct actor_list_impl<first, others...> {
   template <typename T, typename propagator_state_t, typename stepper_t,
             typename navigator_t, typename... Args>
-  static void act(const T& actors_tuple, propagator_state_t& state,
+  static void act(const T& actor_tuple, propagator_state_t& state,
                   const stepper_t& stepper, const navigator_t& navigator,
                   Args&&... args) {
-    constexpr bool has_result = has_result_type_v<first>;
-    const auto& this_actor = std::get<first>(actors_tuple);
-    actor_caller<has_result>::act(this_actor, state, stepper, navigator,
-                                  args...);
-    actor_list_impl<others...>::act(actors_tuple, state, stepper, navigator,
+    const auto& this_actor = std::get<first>(actor_tuple);
+    actor_caller::act(this_actor, state, stepper, navigator, args...);
+    actor_list_impl<others...>::act(actor_tuple, state, stepper, navigator,
                                     args...);
   }
 
   template <typename T, typename propagator_state_t, typename stepper_t,
             typename navigator_t, typename... Args>
-  static bool check(const T& actors_tuple, propagator_state_t& state,
+  static bool check(const T& actor_tuple, propagator_state_t& state,
                     const stepper_t& stepper, const navigator_t& navigator,
                     Args&&... args) {
-    constexpr bool has_result = has_result_type_v<first>;
-    const auto& this_actor = std::get<first>(actors_tuple);
-    return actor_caller<has_result>::check(this_actor, state, stepper,
-                                           navigator, args...) ||
-           actor_list_impl<others...>::check(actors_tuple, state, stepper,
+    const auto& this_actor = std::get<first>(actor_tuple);
+    return actor_caller::check(this_actor, state, stepper, navigator,
+                               args...) ||
+           actor_list_impl<others...>::check(actor_tuple, state, stepper,
                                              navigator, args...);
   }
 };
@@ -107,10 +108,9 @@ struct actor_list_impl<last> {
   static void act(const T& actors_tuple, propagator_state_t& state,
                   const stepper_t& stepper, const navigator_t& navigator,
                   Args&&... args) {
-    constexpr bool has_result = has_result_type_v<last>;
     const auto& this_actor = std::get<last>(actors_tuple);
-    actor_caller<has_result>::act(this_actor, state, stepper, navigator,
-                                  std::forward<Args>(args)...);
+    actor_caller::act(this_actor, state, stepper, navigator,
+                      std::forward<Args>(args)...);
   }
 
   template <typename T, typename propagator_state_t, typename stepper_t,
@@ -118,10 +118,9 @@ struct actor_list_impl<last> {
   static bool check(const T& actors_tuple, propagator_state_t& state,
                     const stepper_t& stepper, const navigator_t& navigator,
                     Args&&... args) {
-    constexpr bool has_result = has_result_type_v<last>;
     const auto& this_actor = std::get<last>(actors_tuple);
-    return actor_caller<has_result>::check(
-        this_actor, state, stepper, navigator, std::forward<Args>(args)...);
+    return actor_caller::check(this_actor, state, stepper, navigator,
+                               std::forward<Args>(args)...);
   }
 };
 
diff --git a/Core/include/Acts/Utilities/detail/MPL/type_collector.hpp b/Core/include/Acts/Utilities/detail/MPL/type_collector.hpp
index 28c380d3bbc..3ff1f0ce994 100644
--- a/Core/include/Acts/Utilities/detail/MPL/type_collector.hpp
+++ b/Core/include/Acts/Utilities/detail/MPL/type_collector.hpp
@@ -7,11 +7,13 @@
 // 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;
 
 /**
@@ -102,4 +104,5 @@ constexpr bool has_action_type_v =
  */
 template <typename T>
 using action_type_t = typename action_type_extractor::extractor_impl<T>;
+
 }  // namespace Acts::detail

From cfe5e7a958a888e94ffb0a9e1959205632c68331 Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Thu, 29 Aug 2024 14:57:13 +0200
Subject: [PATCH 05/15] remove stub functions

---
 .../Material/PropagatorMaterialAssigner.hpp   |  8 -------
 .../Acts/Propagator/MaterialInteractor.hpp    |  8 -------
 .../Acts/Propagator/MultiStepperAborters.hpp  |  7 +-----
 .../Acts/Propagator/StandardAborters.hpp      | 24 +------------------
 .../Acts/Propagator/VolumeCollector.hpp       |  8 -------
 .../Acts/Propagator/detail/SteppingLogger.hpp |  8 -------
 .../CombinatorialKalmanFilter.hpp             |  6 -----
 .../CommonHelpers/MeasurementsCreator.hpp     |  8 -------
 .../Material/VolumeMaterialMapperTests.cpp    |  8 -------
 .../Navigation/DetectorNavigatorTests.cpp     |  8 -------
 .../Core/Propagator/EigenStepperTests.cpp     |  7 +-----
 .../Propagator/KalmanExtrapolatorTests.cpp    |  8 -------
 .../Core/Propagator/PropagatorTests.cpp       |  8 -------
 13 files changed, 3 insertions(+), 113 deletions(-)

diff --git a/Core/include/Acts/Material/PropagatorMaterialAssigner.hpp b/Core/include/Acts/Material/PropagatorMaterialAssigner.hpp
index ca54a7b08d7..57cb73ec312 100644
--- a/Core/include/Acts/Material/PropagatorMaterialAssigner.hpp
+++ b/Core/include/Acts/Material/PropagatorMaterialAssigner.hpp
@@ -84,14 +84,6 @@ struct InteractionVolumeCollector {
       }
     }
   }
-
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-             const navigator_t& /*navigator*/, result_type& /*result*/,
-             const Logger& /*logger*/) const {
-    return false;
-  }
 };
 
 /// @class PropagatorMaterialAssigner
diff --git a/Core/include/Acts/Propagator/MaterialInteractor.hpp b/Core/include/Acts/Propagator/MaterialInteractor.hpp
index 5d1444dadab..ca3cc354b6b 100644
--- a/Core/include/Acts/Propagator/MaterialInteractor.hpp
+++ b/Core/include/Acts/Propagator/MaterialInteractor.hpp
@@ -142,14 +142,6 @@ struct MaterialInteractor {
     }
   }
 
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-             const navigator_t& /*navigator*/, result_type& /*result*/,
-             const Logger& /*logger*/) const {
-    return false;
-  }
-
  private:
   /// @brief This function records the material effect
   ///
diff --git a/Core/include/Acts/Propagator/MultiStepperAborters.hpp b/Core/include/Acts/Propagator/MultiStepperAborters.hpp
index d9ff14ca562..7e817ab79d2 100644
--- a/Core/include/Acts/Propagator/MultiStepperAborters.hpp
+++ b/Core/include/Acts/Propagator/MultiStepperAborters.hpp
@@ -25,12 +25,7 @@ struct MultiStepperSurfaceReached : public SurfaceReached {
   double averageOnSurfaceTolerance = 0.2;
 
   MultiStepperSurfaceReached() = default;
-  MultiStepperSurfaceReached(double oLimit) : SurfaceReached(oLimit) {}
-
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  void act(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-           const navigator_t& /*navigator*/, const Logger& /*logger*/) const {}
+  explicit MultiStepperSurfaceReached(double oLimit) : SurfaceReached(oLimit) {}
 
   /// boolean operator for abort condition without using the result
   ///
diff --git a/Core/include/Acts/Propagator/StandardAborters.hpp b/Core/include/Acts/Propagator/StandardAborters.hpp
index 2db05e76532..7a6f68d14a2 100644
--- a/Core/include/Acts/Propagator/StandardAborters.hpp
+++ b/Core/include/Acts/Propagator/StandardAborters.hpp
@@ -29,11 +29,6 @@ struct PathLimitReached {
   /// Boolean switch for Loop protection
   double internalLimit = std::numeric_limits<double>::max();
 
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  void act(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-           const navigator_t& /*navigator*/, const Logger& /*logger*/) const {}
-
   /// boolean operator for abort condition without using the result
   ///
   /// @tparam propagator_state_t Type of the propagator state
@@ -82,12 +77,7 @@ struct SurfaceReached {
   double nearLimit = -100 * UnitConstants::um;
 
   SurfaceReached() = default;
-  SurfaceReached(double nLimit) : nearLimit(nLimit) {}
-
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  void act(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-           const navigator_t& /*navigator*/, const Logger& /*logger*/) const {}
+  explicit SurfaceReached(double nLimit) : nearLimit(nLimit) {}
 
   /// boolean operator for abort condition without using the result
   ///
@@ -174,13 +164,6 @@ struct ForcedSurfaceReached : SurfaceReached {
 /// This is the condition that the end of World has been reached
 /// it then triggers an propagation abort
 struct EndOfWorldReached {
-  EndOfWorldReached() = default;
-
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  void act(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-           const navigator_t& /*navigator*/, const Logger& /*logger*/) const {}
-
   /// boolean operator for abort condition without using the result
   ///
   /// @tparam propagator_state_t Type of the propagator state
@@ -199,11 +182,6 @@ struct EndOfWorldReached {
 
 /// Aborter that checks if the propagation has reached any surface
 struct AnySurfaceReached {
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  void act(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-           const navigator_t& /*navigator*/, const Logger& /*logger*/) const {}
-
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
   bool check(propagator_state_t& state, const stepper_t& stepper,
diff --git a/Core/include/Acts/Propagator/VolumeCollector.hpp b/Core/include/Acts/Propagator/VolumeCollector.hpp
index 34a1a96b4be..1aa1397e677 100644
--- a/Core/include/Acts/Propagator/VolumeCollector.hpp
+++ b/Core/include/Acts/Propagator/VolumeCollector.hpp
@@ -119,14 +119,6 @@ struct VolumeCollector {
       }
     }
   }
-
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-             const navigator_t& /*navigator*/, result_type& /*result*/,
-             const Logger& /*logger*/) const {
-    return false;
-  }
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Propagator/detail/SteppingLogger.hpp b/Core/include/Acts/Propagator/detail/SteppingLogger.hpp
index 3bc6cb49d4f..c8c47392706 100644
--- a/Core/include/Acts/Propagator/detail/SteppingLogger.hpp
+++ b/Core/include/Acts/Propagator/detail/SteppingLogger.hpp
@@ -94,14 +94,6 @@ struct SteppingLogger {
     }
     result.steps.push_back(std::move(step));
   }
-
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-             const navigator_t& /*navigator*/, result_type& /*result*/,
-             const Logger& /*logger*/) const {
-    return false;
-  }
 };
 
 }  // namespace detail
diff --git a/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp b/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp
index e4820ff5118..4ba7a41c240 100644
--- a/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp
+++ b/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp
@@ -1193,12 +1193,6 @@ class CombinatorialKalmanFilter {
   struct StubPathLimitReached {
     double internalLimit{};
 
-    template <typename propagator_state_t, typename stepper_t,
-              typename navigator_t>
-    void act(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-             const navigator_t& /*navigator*/, const Logger& /*logger*/) const {
-    }
-
     template <typename propagator_state_t, typename stepper_t,
               typename navigator_t>
     bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
diff --git a/Tests/CommonHelpers/Acts/Tests/CommonHelpers/MeasurementsCreator.hpp b/Tests/CommonHelpers/Acts/Tests/CommonHelpers/MeasurementsCreator.hpp
index ae7f963ab03..6e665328518 100644
--- a/Tests/CommonHelpers/Acts/Tests/CommonHelpers/MeasurementsCreator.hpp
+++ b/Tests/CommonHelpers/Acts/Tests/CommonHelpers/MeasurementsCreator.hpp
@@ -143,14 +143,6 @@ struct MeasurementsCreator {
                                              geoId, sourceId);
     }
   }
-
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-             const navigator_t& /*navigator*/, result_type& /*result*/,
-             const Logger& /*logger*/) const {
-    return false;
-  }
 };
 
 /// Propagate the track create smeared measurements from local coordinates.
diff --git a/Tests/UnitTests/Core/Material/VolumeMaterialMapperTests.cpp b/Tests/UnitTests/Core/Material/VolumeMaterialMapperTests.cpp
index 9f06f706a10..d200599b615 100644
--- a/Tests/UnitTests/Core/Material/VolumeMaterialMapperTests.cpp
+++ b/Tests/UnitTests/Core/Material/VolumeMaterialMapperTests.cpp
@@ -75,14 +75,6 @@ struct MaterialCollector {
       result.position.push_back(position);
     }
   }
-
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-             const navigator_t& /*navigator*/, result_type& /*result*/,
-             const Logger& /*logger*/) const {
-    return false;
-  }
 };
 
 }  // namespace Acts
diff --git a/Tests/UnitTests/Core/Navigation/DetectorNavigatorTests.cpp b/Tests/UnitTests/Core/Navigation/DetectorNavigatorTests.cpp
index f58976fa2c7..c117990f1f4 100644
--- a/Tests/UnitTests/Core/Navigation/DetectorNavigatorTests.cpp
+++ b/Tests/UnitTests/Core/Navigation/DetectorNavigatorTests.cpp
@@ -52,14 +52,6 @@ struct StateRecorder {
            const Acts::Logger& /*logger*/) const {
     result.push_back(state.navigation);
   }
-
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-             const navigator_t& /*navigator*/, result_type& /*result*/,
-             const Acts::Logger& /*logger*/) const {
-    return false;
-  }
 };
 
 BOOST_AUTO_TEST_SUITE(DetectorNavigator)
diff --git a/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp b/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp
index af247952dbf..ead7e293421 100644
--- a/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2018-2020 CERN for the benefit of the Acts project
+// Copyright (C) 2018-2024 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
@@ -116,11 +116,6 @@ struct EndOfWorld {
   /// Maximum value in x-direction of the detector
   double maxX = 1_m;
 
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  void act(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-           const navigator_t& /*navigator*/, const Logger& /*logger*/) const {}
-
   /// @brief Main call operator for the abort operation
   ///
   /// @tparam propagator_state_t State of the propagator
diff --git a/Tests/UnitTests/Core/Propagator/KalmanExtrapolatorTests.cpp b/Tests/UnitTests/Core/Propagator/KalmanExtrapolatorTests.cpp
index 55d25709a75..cebbb7885a2 100644
--- a/Tests/UnitTests/Core/Propagator/KalmanExtrapolatorTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/KalmanExtrapolatorTests.cpp
@@ -98,14 +98,6 @@ struct StepWiseActor {
       result.finalized = true;
     }
   }
-
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-             const navigator_t& /*navigator*/, result_type& /*result*/,
-             const Logger& /*logger*/) const {
-    return false;
-  }
 };
 
 ///
diff --git a/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp b/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp
index ca1a75e4236..439525de452 100644
--- a/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp
@@ -129,14 +129,6 @@ struct SurfaceObserver {
       }
     }
   }
-
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-             const navigator_t& /*navigator*/, result_type& /*result*/,
-             const Logger& /*logger*/) const {
-    return false;
-  }
 };
 
 // Global definitions

From add6562db95182d93bfaeda8397f6688d7f88e15 Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Thu, 29 Aug 2024 16:29:27 +0200
Subject: [PATCH 06/15] use fold expressions - thanks stephen

---
 .../detail/actor_list_implementation.hpp      | 97 +++++--------------
 1 file changed, 26 insertions(+), 71 deletions(-)

diff --git a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
index f61af5ff7fa..ef807145157 100644
--- a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
+++ b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
@@ -11,6 +11,7 @@
 #include "Acts/Propagator/ActorConcepts.hpp"
 #include "Acts/Utilities/detail/MPL/type_collector.hpp"
 
+#include <tuple>
 #include <utility>
 
 namespace Acts::detail {
@@ -64,81 +65,35 @@ struct actor_caller {
   }
 };
 
-}  // end of anonymous namespace
-
-/// The dummy list call implementation
-template <typename... actors>
-struct actor_list_impl;
-
-/// The action list call implementation
-/// - it calls 'action' on the current entry of the tuple
-/// - then broadcasts the action call to the remaining tuple
-template <typename first, typename... others>
-struct actor_list_impl<first, others...> {
-  template <typename T, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static void act(const T& actor_tuple, propagator_state_t& state,
-                  const stepper_t& stepper, const navigator_t& navigator,
-                  Args&&... args) {
-    const auto& this_actor = std::get<first>(actor_tuple);
-    actor_caller::act(this_actor, state, stepper, navigator, args...);
-    actor_list_impl<others...>::act(actor_tuple, state, stepper, navigator,
-                                    args...);
-  }
-
-  template <typename T, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static bool check(const T& actor_tuple, propagator_state_t& state,
-                    const stepper_t& stepper, const navigator_t& navigator,
-                    Args&&... args) {
-    const auto& this_actor = std::get<first>(actor_tuple);
-    return actor_caller::check(this_actor, state, stepper, navigator,
-                               args...) ||
-           actor_list_impl<others...>::check(actor_tuple, state, stepper,
-                                             navigator, args...);
-  }
-};
-
-/// The action list call implementation
-/// - it calls 'action' on the last entry of the tuple
-template <typename last>
-struct actor_list_impl<last> {
-  template <typename T, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static void act(const T& actors_tuple, propagator_state_t& state,
-                  const stepper_t& stepper, const navigator_t& navigator,
-                  Args&&... args) {
-    const auto& this_actor = std::get<last>(actors_tuple);
-    actor_caller::act(this_actor, state, stepper, navigator,
-                      std::forward<Args>(args)...);
-  }
-
-  template <typename T, typename propagator_state_t, typename stepper_t,
+}  // namespace
+template <typename... actors_t>
+struct actor_list_impl {
+  template <typename propagator_state_t, typename stepper_t,
             typename navigator_t, typename... Args>
-  static bool check(const T& actors_tuple, propagator_state_t& state,
-                    const stepper_t& stepper, const navigator_t& navigator,
-                    Args&&... args) {
-    const auto& this_actor = std::get<last>(actors_tuple);
-    return actor_caller::check(this_actor, state, stepper, navigator,
-                               std::forward<Args>(args)...);
+  static void act(const std::tuple<actors_t...>& actor_tuple,
+                  propagator_state_t& state, const stepper_t& stepper,
+                  const navigator_t& navigator, Args&&... args) {
+    std::apply(
+        [&](const actors_t&... actor) {
+          (actor_caller::act(actor, state, stepper, navigator,
+                             std::forward<Args>(args)...),
+           ...);
+        },
+        actor_tuple);
   }
-};
 
-/// The empty action list call implementation
-template <>
-struct actor_list_impl<> {
-  template <typename T, typename propagator_state_t, typename stepper_t,
+  template <typename propagator_state_t, typename stepper_t,
             typename navigator_t, typename... Args>
-  static void act(const T& /*actors_tuple*/, propagator_state_t& /*state*/,
-                  const stepper_t& /*stepper*/,
-                  const navigator_t& /*navigator*/, Args&&... /*args*/) {}
-
-  template <typename T, typename propagator_state_t, typename stepper_t,
-            typename navigator_t, typename... Args>
-  static bool check(const T& /*actors_tuple*/, propagator_state_t& /*state*/,
-                    const stepper_t& /*stepper*/,
-                    const navigator_t& /*navigator*/, Args&&... /*args*/) {
-    return false;
+  static bool check(const std::tuple<actors_t...>& actor_tuple,
+                    propagator_state_t& state, const stepper_t& stepper,
+                    const navigator_t& navigator, Args&&... args) {
+    return std::apply(
+        [&](const actors_t&... actor) {
+          return (actor_caller::check(actor, state, stepper, navigator,
+                                      std::forward<Args>(args)...) ||
+                  ...);
+        },
+        actor_tuple);
   }
 };
 

From b90834b16692f91c315a94bd55af039e15fd7b29 Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Thu, 29 Aug 2024 16:30:28 +0200
Subject: [PATCH 07/15] nl

---
 .../include/Acts/Propagator/detail/actor_list_implementation.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
index ef807145157..988a988cc3b 100644
--- a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
+++ b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
@@ -66,6 +66,7 @@ struct actor_caller {
 };
 
 }  // namespace
+
 template <typename... actors_t>
 struct actor_list_impl {
   template <typename propagator_state_t, typename stepper_t,

From 21aa19c19fa3838ebe960f6037e3f3de346d0e12 Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Fri, 30 Aug 2024 14:35:37 +0200
Subject: [PATCH 08/15] pr feedback

---
 .../detail/actor_list_implementation.hpp       | 18 ++++++++----------
 .../Core/Propagator/DirectNavigatorTests.cpp   |  4 ++--
 2 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
index 988a988cc3b..eab30b5a8dd 100644
--- a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
+++ b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
@@ -23,11 +23,10 @@ struct actor_caller {
             typename navigator_t, typename... Args>
   static void act(const actor_t& actor, propagator_state_t& state,
                   const stepper_t& stepper, const navigator_t& navigator,
-                  Args&&... args) {
-    static_assert(
-        Actor<actor_t, propagator_state_t, stepper_t, navigator_t, Args...>,
-        "The actor does not fulfill the Actor concept");
-
+                  Args&&... args)
+    requires(
+        Actor<actor_t, propagator_state_t, stepper_t, navigator_t, Args...>)
+  {
     if constexpr (ActorHasAct<actor_t, propagator_state_t, stepper_t,
                               navigator_t, Args...>) {
       if constexpr (ActorHasResult<actor_t>) {
@@ -44,11 +43,10 @@ struct actor_caller {
             typename navigator_t, typename... Args>
   static bool check(const actor_t& actor, propagator_state_t& state,
                     const stepper_t& stepper, const navigator_t& navigator,
-                    Args&&... args) {
-    static_assert(
-        Actor<actor_t, propagator_state_t, stepper_t, navigator_t, Args...>,
-        "The actor does not fulfill the Actor concept");
-
+                    Args&&... args)
+    requires(
+        Actor<actor_t, propagator_state_t, stepper_t, navigator_t, Args...>)
+  {
     if constexpr (ActorHasAbort<actor_t, propagator_state_t, stepper_t,
                                 navigator_t, Args...>) {
       if constexpr (ActorHasResult<actor_t>) {
diff --git a/Tests/UnitTests/Core/Propagator/DirectNavigatorTests.cpp b/Tests/UnitTests/Core/Propagator/DirectNavigatorTests.cpp
index 44a5f76b09c..44e3b51d63d 100644
--- a/Tests/UnitTests/Core/Propagator/DirectNavigatorTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/DirectNavigatorTests.cpp
@@ -106,11 +106,11 @@ void runTest(const rpropagator_t& rprop, const dpropagator_t& dprop, double pT,
   using EndOfWorld = EndOfWorldReached;
 
   // Action list and abort list
-  using RefereceActorList =
+  using ReferenceActorList =
       ActorList<MaterialInteractor, SurfaceCollector<>, EndOfWorld>;
 
   // Options definition
-  using Options = typename rpropagator_t::template Options<RefereceActorList>;
+  using Options = typename rpropagator_t::template Options<ReferenceActorList>;
   Options pOptions(tgContext, mfContext);
   if (oversteppingTest) {
     pOptions.stepping.maxStepSize = oversteppingMaxStepSize;

From 09941f08139743de664bb592f6b22cd4db6a2a8a Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Sun, 8 Sep 2024 08:25:02 +0200
Subject: [PATCH 09/15] pr feedback

---
 .../include/Acts/Propagator/ActorConcepts.hpp | 18 +++---
 Core/include/Acts/Propagator/ActorList.hpp    | 60 ++++++++++++++-----
 .../Acts/Propagator/MultiStepperAborters.hpp  |  8 +--
 Core/include/Acts/Propagator/Propagator.ipp   |  7 ++-
 .../Acts/Propagator/StandardAborters.hpp      | 17 +++---
 .../detail/actor_list_implementation.hpp      | 27 +++++----
 .../CombinatorialKalmanFilter.hpp             | 20 +++----
 .../TrackFitting/GlobalChiSquareFitter.hpp    |  6 +-
 .../Acts/TrackFitting/KalmanFitter.hpp        |  9 +--
 .../Acts/TrackFitting/detail/GsfActor.hpp     |  6 +-
 .../Kernel/detail/SimulationActor.hpp         |  9 +--
 .../Core/Propagator/EigenStepperTests.cpp     | 11 ++--
 12 files changed, 116 insertions(+), 82 deletions(-)

diff --git a/Core/include/Acts/Propagator/ActorConcepts.hpp b/Core/include/Acts/Propagator/ActorConcepts.hpp
index 9730228d02c..7ec556b6fc0 100644
--- a/Core/include/Acts/Propagator/ActorConcepts.hpp
+++ b/Core/include/Acts/Propagator/ActorConcepts.hpp
@@ -50,14 +50,14 @@ concept ActorHasAct =
 
 template <typename actor_t, typename propagator_state_t, typename stepper_t,
           typename navigator_t, typename... Args>
-concept ActorHasAbortWithResult =
-    requires(const actor_t& a, propagator_state_t& state,
-             const stepper_t& stepper, const navigator_t& navigator,
-             typename actor_t::result_type& result, Args&&... args) {
-      {
-        a.check(state, stepper, navigator, result, std::forward<Args>(args)...)
-      } -> std::same_as<bool>;
-    };
+concept ActorHasAbortWithResult = requires(
+    const actor_t& a, propagator_state_t& state, const stepper_t& stepper,
+    const navigator_t& navigator, typename actor_t::result_type& result,
+    Args&&... args) {
+  {
+    a.checkAbort(state, stepper, navigator, result, std::forward<Args>(args)...)
+  } -> std::same_as<bool>;
+};
 
 template <typename actor_t, typename propagator_state_t, typename stepper_t,
           typename navigator_t, typename... Args>
@@ -65,7 +65,7 @@ concept ActorHasAbortWithoutResult = requires(
     const actor_t& a, propagator_state_t& state, const stepper_t& stepper,
     const navigator_t& navigator, Args&&... args) {
   {
-    a.check(state, stepper, navigator, std::forward<Args>(args)...)
+    a.checkAbort(state, stepper, navigator, std::forward<Args>(args)...)
   } -> std::same_as<bool>;
 };
 
diff --git a/Core/include/Acts/Propagator/ActorList.hpp b/Core/include/Acts/Propagator/ActorList.hpp
index 39f74e8e2d1..fa02e6597dd 100644
--- a/Core/include/Acts/Propagator/ActorList.hpp
+++ b/Core/include/Acts/Propagator/ActorList.hpp
@@ -9,7 +9,6 @@
 #pragma once
 
 #include "Acts/Propagator/detail/actor_list_implementation.hpp"
-#include "Acts/Utilities/detail/Extendable.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"
@@ -27,13 +26,21 @@ namespace Acts {
 /// to define a list of different actors_t that are each
 /// executed during the stepping procedure
 template <typename... actors_t>
-struct ActorList : public detail::Extendable<actors_t...> {
+struct ActorList {
  private:
+  static_assert(
+      detail::all_of_v<std::is_default_constructible<actors_t>::value...>,
+      "all actors must be default constructible");
+  static_assert(
+      detail::all_of_v<std::is_copy_constructible<actors_t>::value...>,
+      "all actors must be copy constructible");
+  static_assert(
+      detail::all_of_v<std::is_move_constructible<actors_t>::value...>,
+      "all actors must be move constructible");
+
   static_assert(!detail::has_duplicates_v<actors_t...>,
                 "same action type specified several times");
 
-  using detail::Extendable<actors_t...>::tuple;
-
  public:
   /// @cond
   // This uses the type collector and unpacks using the `R` meta function
@@ -43,8 +50,6 @@ struct ActorList : public detail::Extendable<actors_t...> {
       hana::template_<R>))::type;
   /// @endcond
 
-  using detail::Extendable<actors_t...>::get;
-
   /// Default constructor
   ActorList() = default;
 
@@ -72,20 +77,40 @@ struct ActorList : public detail::Extendable<actors_t...> {
   /// Constructor from tuple
   ///
   /// @param actors Source extensions tuple
-  ActorList(const std::tuple<actors_t...>& actors)
-      : detail::Extendable<actors_t...>(actors) {}
+  ActorList(const std::tuple<actors_t...>& actors) : m_actors(actors) {}
 
   /// Constructor from tuple move
   ///
   /// @param actors Source extensions tuple
-  ActorList(std::tuple<actors_t...>&& actors)
-      : detail::Extendable<actors_t...>(std::move(actors)) {}
+  ActorList(std::tuple<actors_t...>&& actors) : m_actors(std::move(actors)) {}
+
+  /// Const retrieval of an actor of a specific type
+  ///
+  /// @tparam actor_t Type of the Actor to be retrieved
+  template <typename actor_t>
+  const actor_t& get() const {
+    return std::get<actor_t>(m_actors);
+  }
+
+  /// Non-const retrieval of an actor of a specific type
+  ///
+  /// @tparam actor_t Type of the Actor to be retrieved
+  template <typename actor_t>
+  actor_t& get() {
+    return std::get<actor_t>(m_actors);
+  }
 
   /// Append new entries and return a new condition
+  ///
+  /// @tparam appendices_t Types of appended entries to the tuple
+  ///
+  /// @param aps The actors to be appended to the new ActorList
+  ///
+  /// @return A new ActorList with the appended actors
   template <typename... appendices_t>
   ActorList<actors_t..., appendices_t...> append(appendices_t... aps) const {
     auto catTuple =
-        std::tuple_cat(tuple(), std::tuple<appendices_t...>(aps...));
+        std::tuple_cat(m_actors, std::tuple<appendices_t...>(aps...));
     return ActorList<actors_t..., appendices_t...>(std::move(catTuple));
   }
 
@@ -104,7 +129,7 @@ struct ActorList : public detail::Extendable<actors_t...> {
   void act(propagator_state_t& state, const stepper_t& stepper,
            const navigator_t& navigator, Args&&... args) const {
     using impl = detail::actor_list_impl<actors_t...>;
-    impl::act(tuple(), state, stepper, navigator, std::forward<Args>(args)...);
+    impl::act(m_actors, state, stepper, navigator, std::forward<Args>(args)...);
   }
 
   /// Check call which broadcasts the call to the tuple() members of the list
@@ -119,12 +144,15 @@ struct ActorList : public detail::Extendable<actors_t...> {
   /// @param [in] args are the arguments to be passed to the aborters
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t, typename... Args>
-  bool check(propagator_state_t& state, const stepper_t& stepper,
-             const navigator_t& navigator, Args&&... args) const {
+  bool checkAbort(propagator_state_t& state, const stepper_t& stepper,
+                  const navigator_t& navigator, Args&&... args) const {
     using impl = detail::actor_list_impl<actors_t...>;
-    return impl::check(tuple(), state, stepper, navigator,
-                       std::forward<Args>(args)...);
+    return impl::checkAbort(m_actors, state, stepper, navigator,
+                            std::forward<Args>(args)...);
   }
+
+ private:
+  std::tuple<actors_t...> m_actors;
 };
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Propagator/MultiStepperAborters.hpp b/Core/include/Acts/Propagator/MultiStepperAborters.hpp
index 7e817ab79d2..6d1e0e4f131 100644
--- a/Core/include/Acts/Propagator/MultiStepperAborters.hpp
+++ b/Core/include/Acts/Propagator/MultiStepperAborters.hpp
@@ -39,8 +39,8 @@ struct MultiStepperSurfaceReached : public SurfaceReached {
   /// @param logger a logger instance
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool check(propagator_state_t& state, const stepper_t& stepper,
-             const navigator_t& navigator, const Logger& logger) const {
+  bool checkAbort(propagator_state_t& state, const stepper_t& stepper,
+                  const navigator_t& navigator, const Logger& logger) const {
     if (surface == nullptr) {
       ACTS_VERBOSE(
           "MultiStepperSurfaceReached aborter | "
@@ -82,8 +82,8 @@ struct MultiStepperSurfaceReached : public SurfaceReached {
       auto singleState = cmp.singleState(state);
       const auto& singleStepper = cmp.singleStepper(stepper);
 
-      if (!SurfaceReached::check(singleState, singleStepper, navigator,
-                                 logger)) {
+      if (!SurfaceReached::checkAbort(singleState, singleStepper, navigator,
+                                      logger)) {
         reached = false;
       } else {
         cmp.status() = Acts::Intersection3D::Status::onSurface;
diff --git a/Core/include/Acts/Propagator/Propagator.ipp b/Core/include/Acts/Propagator/Propagator.ipp
index 7578819e3ec..54e752075f6 100644
--- a/Core/include/Acts/Propagator/Propagator.ipp
+++ b/Core/include/Acts/Propagator/Propagator.ipp
@@ -41,7 +41,8 @@ auto Acts::Propagator<S, N>::propagate(propagator_state_t& state) const
   bool terminatedNormally = true;
 
   // Pre-Stepping: abort condition check
-  if (!state.options.actorList.check(state, m_stepper, m_navigator, logger())) {
+  if (!state.options.actorList.checkAbort(state, m_stepper, m_navigator,
+                                          logger())) {
     // Stepping loop
     ACTS_VERBOSE("Starting stepping loop.");
 
@@ -73,8 +74,8 @@ auto Acts::Propagator<S, N>::propagate(propagator_state_t& state) const
       state.stage = PropagatorStage::postStep;
       m_navigator.postStep(state, m_stepper);
       state.options.actorList.act(state, m_stepper, m_navigator, logger());
-      if (state.options.actorList.check(state, m_stepper, m_navigator,
-                                        logger())) {
+      if (state.options.actorList.checkAbort(state, m_stepper, m_navigator,
+                                             logger())) {
         terminatedNormally = true;
         break;
       }
diff --git a/Core/include/Acts/Propagator/StandardAborters.hpp b/Core/include/Acts/Propagator/StandardAborters.hpp
index 7a6f68d14a2..7cb9648c088 100644
--- a/Core/include/Acts/Propagator/StandardAborters.hpp
+++ b/Core/include/Acts/Propagator/StandardAborters.hpp
@@ -41,8 +41,8 @@ struct PathLimitReached {
   /// @param logger a logger instance
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool check(propagator_state_t& state, const stepper_t& stepper,
-             const navigator_t& navigator, const Logger& logger) const {
+  bool checkAbort(propagator_state_t& state, const stepper_t& stepper,
+                  const navigator_t& navigator, const Logger& logger) const {
     (void)navigator;
 
     // Check if the maximum allowed step size has to be updated
@@ -91,8 +91,8 @@ struct SurfaceReached {
   /// @param logger a logger instance
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool check(propagator_state_t& state, const stepper_t& stepper,
-             const navigator_t& navigator, const Logger& logger) const {
+  bool checkAbort(propagator_state_t& state, const stepper_t& stepper,
+                  const navigator_t& navigator, const Logger& logger) const {
     if (surface == nullptr) {
       ACTS_VERBOSE("SurfaceReached aborter | Target surface not set.");
       return false;
@@ -173,8 +173,9 @@ struct EndOfWorldReached {
   /// @param [in] navigator The navigator object
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool check(propagator_state_t& state, const stepper_t& /*stepper*/,
-             const navigator_t& navigator, const Logger& /*logger*/) const {
+  bool checkAbort(propagator_state_t& state, const stepper_t& /*stepper*/,
+                  const navigator_t& navigator,
+                  const Logger& /*logger*/) const {
     bool endOfWorld = navigator.endOfWorldReached(state.navigation);
     return endOfWorld;
   }
@@ -184,8 +185,8 @@ struct EndOfWorldReached {
 struct AnySurfaceReached {
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool check(propagator_state_t& state, const stepper_t& stepper,
-             const navigator_t& navigator, const Logger& logger) const {
+  bool checkAbort(propagator_state_t& state, const stepper_t& stepper,
+                  const navigator_t& navigator, const Logger& logger) const {
     (void)stepper;
     (void)logger;
 
diff --git a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
index eab30b5a8dd..69f4af768f5 100644
--- a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
+++ b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
@@ -41,21 +41,22 @@ struct actor_caller {
 
   template <typename actor_t, typename propagator_state_t, typename stepper_t,
             typename navigator_t, typename... Args>
-  static bool check(const actor_t& actor, propagator_state_t& state,
-                    const stepper_t& stepper, const navigator_t& navigator,
-                    Args&&... args)
+  static bool checkAbort(const actor_t& actor, propagator_state_t& state,
+                         const stepper_t& stepper, const navigator_t& navigator,
+                         Args&&... args)
     requires(
         Actor<actor_t, propagator_state_t, stepper_t, navigator_t, Args...>)
   {
     if constexpr (ActorHasAbort<actor_t, propagator_state_t, stepper_t,
                                 navigator_t, Args...>) {
       if constexpr (ActorHasResult<actor_t>) {
-        return actor.check(state, stepper, navigator,
-                           state.template get<detail::result_type_t<actor_t>>(),
-                           std::forward<Args>(args)...);
+        return actor.checkAbort(
+            state, stepper, navigator,
+            state.template get<detail::result_type_t<actor_t>>(),
+            std::forward<Args>(args)...);
       } else {
-        return actor.check(state, stepper, navigator,
-                           std::forward<Args>(args)...);
+        return actor.checkAbort(state, stepper, navigator,
+                                std::forward<Args>(args)...);
       }
     }
 
@@ -83,13 +84,13 @@ struct actor_list_impl {
 
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t, typename... Args>
-  static bool check(const std::tuple<actors_t...>& actor_tuple,
-                    propagator_state_t& state, const stepper_t& stepper,
-                    const navigator_t& navigator, Args&&... args) {
+  static bool checkAbort(const std::tuple<actors_t...>& actor_tuple,
+                         propagator_state_t& state, const stepper_t& stepper,
+                         const navigator_t& navigator, Args&&... args) {
     return std::apply(
         [&](const actors_t&... actor) {
-          return (actor_caller::check(actor, state, stepper, navigator,
-                                      std::forward<Args>(args)...) ||
+          return (actor_caller::checkAbort(actor, state, stepper, navigator,
+                                           std::forward<Args>(args)...) ||
                   ...);
         },
         actor_tuple);
diff --git a/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp b/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp
index 4ba7a41c240..b1e46491ace 100644
--- a/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp
+++ b/Core/include/Acts/TrackFinding/CombinatorialKalmanFilter.hpp
@@ -584,11 +584,11 @@ class CombinatorialKalmanFilter {
       }
 
       const bool isEndOfWorldReached =
-          endOfWorldReached.check(state, stepper, navigator, logger());
-      const bool isPathLimitReached =
-          result.pathLimitReached.check(state, stepper, navigator, logger());
+          endOfWorldReached.checkAbort(state, stepper, navigator, logger());
+      const bool isPathLimitReached = result.pathLimitReached.checkAbort(
+          state, stepper, navigator, logger());
       const bool isTargetReached =
-          targetReached.check(state, stepper, navigator, logger());
+          targetReached.checkAbort(state, stepper, navigator, logger());
       const bool allBranchesStopped = result.activeBranches.empty();
       if (isEndOfWorldReached || isPathLimitReached || isTargetReached ||
           allBranchesStopped) {
@@ -643,9 +643,9 @@ class CombinatorialKalmanFilter {
 
     template <typename propagator_state_t, typename stepper_t,
               typename navigator_t>
-    bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-               const navigator_t& /*navigator*/, const result_type& result,
-               const Logger& /*logger*/) const {
+    bool checkAbort(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+                    const navigator_t& /*navigator*/, const result_type& result,
+                    const Logger& /*logger*/) const {
       return !result.lastError.ok() || result.finished;
     }
 
@@ -1195,9 +1195,9 @@ class CombinatorialKalmanFilter {
 
     template <typename propagator_state_t, typename stepper_t,
               typename navigator_t>
-    bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-               const navigator_t& /*navigator*/,
-               const Logger& /*logger*/) const {
+    bool checkAbort(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+                    const navigator_t& /*navigator*/,
+                    const Logger& /*logger*/) const {
       return false;
     }
   };
diff --git a/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp b/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp
index c00012e7cf5..4c1ad047336 100644
--- a/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp
+++ b/Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp
@@ -631,9 +631,9 @@ class Gx2Fitter {
 
     template <typename propagator_state_t, typename stepper_t,
               typename navigator_t, typename result_t>
-    bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-               const navigator_t& /*navigator*/, const result_t& result,
-               const Logger& /*logger*/) const {
+    bool checkAbort(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+                    const navigator_t& /*navigator*/, const result_t& result,
+                    const Logger& /*logger*/) const {
       if (!result.result.ok() || result.finished) {
         return true;
       }
diff --git a/Core/include/Acts/TrackFitting/KalmanFitter.hpp b/Core/include/Acts/TrackFitting/KalmanFitter.hpp
index 36478935ceb..4bb5a8e86de 100644
--- a/Core/include/Acts/TrackFitting/KalmanFitter.hpp
+++ b/Core/include/Acts/TrackFitting/KalmanFitter.hpp
@@ -462,7 +462,8 @@ class KalmanFitter {
             // Remember the track fitting is done
             result.finished = true;
           }
-        } else if (targetReached.check(state, stepper, navigator, logger())) {
+        } else if (targetReached.checkAbort(state, stepper, navigator,
+                                            logger())) {
           ACTS_VERBOSE("Completing with fitted track parameter");
           // Transport & bind the parameter to the final surface
           auto res = stepper.boundState(state.stepping, *targetReached.surface,
@@ -501,9 +502,9 @@ class KalmanFitter {
 
     template <typename propagator_state_t, typename stepper_t,
               typename navigator_t>
-    bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-               const navigator_t& /*navigator*/, const result_type& result,
-               const Logger& /*logger*/) const {
+    bool checkAbort(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+                    const navigator_t& /*navigator*/, const result_type& result,
+                    const Logger& /*logger*/) const {
       if (!result.result.ok() || result.finished) {
         return true;
       }
diff --git a/Core/include/Acts/TrackFitting/detail/GsfActor.hpp b/Core/include/Acts/TrackFitting/detail/GsfActor.hpp
index 9babe83a10a..ea45162c5dd 100644
--- a/Core/include/Acts/TrackFitting/detail/GsfActor.hpp
+++ b/Core/include/Acts/TrackFitting/detail/GsfActor.hpp
@@ -335,9 +335,9 @@ struct GsfActor {
 
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool check(propagator_state_t& state, const stepper_t& /*stepper*/,
-             const navigator_t& navigator, result_type& /*result*/,
-             const Logger& /*logger*/) const {
+  bool checkAbort(propagator_state_t& state, const stepper_t& /*stepper*/,
+                  const navigator_t& navigator, result_type& /*result*/,
+                  const Logger& /*logger*/) const {
     return navigator.navigationBreak(state.navigation);
   }
 
diff --git a/Fatras/include/ActsFatras/Kernel/detail/SimulationActor.hpp b/Fatras/include/ActsFatras/Kernel/detail/SimulationActor.hpp
index ffcd76891a6..6cabd7f497d 100644
--- a/Fatras/include/ActsFatras/Kernel/detail/SimulationActor.hpp
+++ b/Fatras/include/ActsFatras/Kernel/detail/SimulationActor.hpp
@@ -76,7 +76,8 @@ struct SimulationActor {
       return;
     }
 
-    if (Acts::EndOfWorldReached{}.check(state, stepper, navigator, logger)) {
+    if (Acts::EndOfWorldReached{}.checkAbort(state, stepper, navigator,
+                                             logger)) {
       result.isAlive = false;
       return;
     }
@@ -204,9 +205,9 @@ struct SimulationActor {
 
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool check(propagator_state_t & /*state*/, const stepper_t & /*stepper*/,
-             const navigator_t & /*navigator*/, const result_type &result,
-             const Acts::Logger & /*logger*/) const {
+  bool checkAbort(propagator_state_t & /*state*/, const stepper_t & /*stepper*/,
+                  const navigator_t & /*navigator*/, const result_type &result,
+                  const Acts::Logger & /*logger*/) const {
     // must return true if the propagation should abort
     return !result.isAlive;
   }
diff --git a/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp b/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp
index ead7e293421..33e2178c3fb 100644
--- a/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/EigenStepperTests.cpp
@@ -129,8 +129,9 @@ struct EndOfWorld {
   /// @return Boolean statement if the particle is still in the detector
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool check(propagator_state_t& state, const stepper_t& stepper,
-             const navigator_t& /*navigator*/, const Logger& /*logger*/) const {
+  bool checkAbort(propagator_state_t& state, const stepper_t& stepper,
+                  const navigator_t& /*navigator*/,
+                  const Logger& /*logger*/) const {
     const double tolerance = state.options.surfaceTolerance;
     if (maxX - std::abs(stepper.position(state.stepping).x()) <= tolerance ||
         std::abs(stepper.position(state.stepping).y()) >= 0.5_m ||
@@ -179,9 +180,9 @@ struct StepCollector {
 
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
-  bool check(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
-             const navigator_t& /*navigator*/, result_type& /*result*/,
-             const Logger& /*logger*/) const {
+  bool checkAbort(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+                  const navigator_t& /*navigator*/, result_type& /*result*/,
+                  const Logger& /*logger*/) const {
     return false;
   }
 };

From c534b69d102eabc292ce6b6a7645dbab6b0694b6 Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Sun, 8 Sep 2024 08:30:51 +0200
Subject: [PATCH 10/15] fix gsf?

---
 .../Acts/TrackFitting/GaussianSumFitter.hpp   | 21 ++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp b/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp
index 0cc9afaf17a..b232a6e4ac4 100644
--- a/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp
+++ b/Core/include/Acts/TrackFitting/GaussianSumFitter.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2021 CERN for the benefit of the Acts project
+// Copyright (C) 2021-2024 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
@@ -75,6 +75,20 @@ struct GaussianSumFitter {
   /// The actor type
   using GsfActor = detail::GsfActor<bethe_heitler_approx_t, traj_t>;
 
+  /// This allows to break the propagation by setting the navigationBreak
+  /// TODO refactor once we can do this more elegantly
+  struct NavigationBreakAborter {
+    NavigationBreakAborter() = default;
+
+    template <typename propagator_state_t, typename stepper_t,
+              typename navigator_t>
+    bool checkAbort(propagator_state_t& state, const stepper_t& /*stepper*/,
+                    const navigator_t& navigator,
+                    const Logger& /*logger*/) const {
+      return navigator.navigationBreak(state.navigation);
+    }
+  };
+
   /// @brief The fit function for the Direct navigator
   template <typename source_link_it_t, typename start_parameters_t,
             typename track_container_t, template <typename> class holder_t>
@@ -90,7 +104,7 @@ struct GaussianSumFitter {
 
     // Initialize the forward propagation with the DirectNavigator
     auto fwdPropInitializer = [&sSequence, this](const auto& opts) {
-      using Actors = ActorList<GsfActor>;
+      using Actors = ActorList<GsfActor, NavigationBreakAborter>;
       using PropagatorOptions = typename propagator_t::template Options<Actors>;
 
       PropagatorOptions propOptions(opts.geoContext, opts.magFieldContext);
@@ -141,7 +155,8 @@ struct GaussianSumFitter {
 
     // Initialize the forward propagation with the DirectNavigator
     auto fwdPropInitializer = [this](const auto& opts) {
-      using Actors = ActorList<GsfActor, EndOfWorldReached>;
+      using Actors =
+          ActorList<GsfActor, EndOfWorldReached, NavigationBreakAborter>;
       using PropagatorOptions = typename propagator_t::template Options<Actors>;
 
       PropagatorOptions propOptions(opts.geoContext, opts.magFieldContext);

From dd3640f73dfd303c6c439df5bd4751c75489b497 Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Sun, 8 Sep 2024 10:46:01 +0200
Subject: [PATCH 11/15] fix gsf?

---
 Core/include/Acts/TrackFitting/detail/GsfActor.hpp | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/Core/include/Acts/TrackFitting/detail/GsfActor.hpp b/Core/include/Acts/TrackFitting/detail/GsfActor.hpp
index ea45162c5dd..3cdf50c6d15 100644
--- a/Core/include/Acts/TrackFitting/detail/GsfActor.hpp
+++ b/Core/include/Acts/TrackFitting/detail/GsfActor.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2022-2024 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
@@ -333,14 +333,6 @@ struct GsfActor {
     }
   }
 
-  template <typename propagator_state_t, typename stepper_t,
-            typename navigator_t>
-  bool checkAbort(propagator_state_t& state, const stepper_t& /*stepper*/,
-                  const navigator_t& navigator, result_type& /*result*/,
-                  const Logger& /*logger*/) const {
-    return navigator.navigationBreak(state.navigation);
-  }
-
   template <typename propagator_state_t, typename stepper_t,
             typename navigator_t>
   void convoluteComponents(propagator_state_t& state, const stepper_t& stepper,

From 94bd9329a9a3829e8bdd6501c1b117342bbca5e6 Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Sun, 8 Sep 2024 11:16:35 +0200
Subject: [PATCH 12/15] fix doc

---
 docs/core/propagation.md | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/docs/core/propagation.md b/docs/core/propagation.md
index 729e939ceb8..702926066d2 100644
--- a/docs/core/propagation.md
+++ b/docs/core/propagation.md
@@ -18,9 +18,9 @@ The interaction of these two components is handled by the {class}`Acts::Propagat
 Propagator<Navigator, Stepper>
 ```
 
-Additional to these mandatory components, the propagator can be equipped with **Actors** and **Aborters** to allow for custom behaviour. These are function objects that are hooked in the propagation loop. Actors just perform some action on the propagator state (e.g. the {class}`Acts::KalmanFitter` is an actor), aborts can abort propagation (e.g., the {struct}`Acts::PathLimitReached`).
+Additional to these mandatory components, the propagator can be equipped with **Actors** to allow for custom behaviour. These are function objects that are hooked in the propagation loop. Actors just perform some action on the propagator state (e.g. the {class}`Acts::KalmanFitter` is an actor), aborts can abort propagation (e.g., the {struct}`Acts::PathLimitReached`).
 
-The propagator exposes its state to the actors and aborters as arguments to `operator()`. Actors must define a default-constructable `result_type`, which can be modified in each call:
+The propagator exposes its state to the actors as arguments to `act()` and `checkAbort()`. Actors must define a default-constructable `result_type`, which can be modified in each call:
 
 ```cpp
 template<typename propagator_state_t, typename stepper_t>
@@ -36,19 +36,17 @@ The result of a propagation consists of the track parameters at the endpoint of
 ## Initialization and running
 
 The {class}`Acts::Propagator` is initialized with the helper class
-{struct}`Acts::PropagatorOptions`, which is templated on the list of actors and
-aborters. This is done with the classes {struct}`Acts::ActionList` and
-{struct}`Acts::AbortList` (which are in fact small wrappers around
-`std::tuple`):
+{struct}`Acts::PropagatorOptions`, which is templated on the list of actors.
+This is done with the class {struct}`Acts::ActorList`
+(which are in fact small wrappers around `std::tuple`):
 
 ```cpp
 using MyOptions = Acts::PropagatorOptions<
-                    Acts::ActionList<MyActor1, MyActor2>,
-                    Acts::AbortList<MyAborter1, MyAborter2>
+                    Acts::ActorList<MyActor1, MyActor2>
                   >;
 ```
 
-The actors and aborters are instantiated with the options and can be accessed with the `get`-method that expects the corresponding actor type as template parameter. Besides this, the {struct}`Acts::PropagatorOptions` also contains a lot of general options like the `maxStepSize`:
+The actors are instantiated with the options and can be accessed with the `get`-method that expects the corresponding actor type as template parameter. Besides this, the {struct}`Acts::PropagatorOptions` also contains a lot of general options like the `maxStepSize`:
 
 ```cpp
 auto options = MyOptions();
@@ -63,7 +61,7 @@ The propagator also contains a loop-protection mechanism. It estimates a circle
 :::
 
 To run the propagation, we must call the member function `propagate(...)` with the initial track parameters and the propagator options. There are several overloads to the `propagate(...)` function, which allow further customization:
-* With/without a target surface: The overload with a target surface automatically adds an aborter for the passed `Surface` to the `AbortList`.
+* With/without a target surface: The overload with a target surface automatically adds an aborter for the passed `Surface` to the `ActorList`.
 * With/without a prepared result object: Without a result object, a suitable result object is default-constructed internally.
 
 The result is an instance of {class}`Acts::Result`. It contains the actual result, or an error code in case something went wrong. In the actual result, the results of the different actors can again be accessed via a `get` method:

From f9fe135d0f2abce0686ee8e79899458f74c40ec7 Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Wed, 11 Sep 2024 08:20:44 +0200
Subject: [PATCH 13/15] pr feedback

---
 .../include/Acts/Propagator/ActorConcepts.hpp | 78 +++++++------------
 Core/include/Acts/Propagator/ActorList.hpp    | 20 ++---
 .../Acts/TrackFitting/KalmanFitter.hpp        |  5 +-
 3 files changed, 36 insertions(+), 67 deletions(-)

diff --git a/Core/include/Acts/Propagator/ActorConcepts.hpp b/Core/include/Acts/Propagator/ActorConcepts.hpp
index 7ec556b6fc0..abbe1ae1d8a 100644
--- a/Core/include/Acts/Propagator/ActorConcepts.hpp
+++ b/Core/include/Acts/Propagator/ActorConcepts.hpp
@@ -17,17 +17,6 @@ namespace Acts {
 template <typename actor_t>
 concept ActorHasResult = requires { typename actor_t::result_type; };
 
-template <typename actor_t, typename propagator_state_t, typename stepper_t,
-          typename navigator_t, typename... Args>
-concept ActorHasActWithResult =
-    requires(const actor_t& a, propagator_state_t& state,
-             const stepper_t& stepper, const navigator_t& navigator,
-             typename actor_t::result_type& result, Args&&... args) {
-      {
-        a.act(state, stepper, navigator, result, std::forward<Args>(args)...)
-      } -> std::same_as<void>;
-    };
-
 template <typename actor_t, typename propagator_state_t, typename stepper_t,
           typename navigator_t, typename... Args>
 concept ActorHasActWithoutResult = requires(
@@ -40,24 +29,23 @@ concept ActorHasActWithoutResult = requires(
 
 template <typename actor_t, typename propagator_state_t, typename stepper_t,
           typename navigator_t, typename... Args>
-concept ActorHasAct =
-    (!ActorHasResult<actor_t> &&
-     ActorHasActWithoutResult<actor_t, propagator_state_t, stepper_t,
-                              navigator_t, Args...>) ||
-    (ActorHasResult<actor_t> &&
-     ActorHasActWithResult<actor_t, propagator_state_t, stepper_t, navigator_t,
-                           Args...>);
+concept ActorHasActWithResult =
+    ActorHasResult<actor_t> &&
+    requires(const actor_t& a, propagator_state_t& state,
+             const stepper_t& stepper, const navigator_t& navigator,
+             typename actor_t::result_type& result, Args&&... args) {
+      {
+        a.act(state, stepper, navigator, result, std::forward<Args>(args)...)
+      } -> std::same_as<void>;
+    };
 
 template <typename actor_t, typename propagator_state_t, typename stepper_t,
           typename navigator_t, typename... Args>
-concept ActorHasAbortWithResult = requires(
-    const actor_t& a, propagator_state_t& state, const stepper_t& stepper,
-    const navigator_t& navigator, typename actor_t::result_type& result,
-    Args&&... args) {
-  {
-    a.checkAbort(state, stepper, navigator, result, std::forward<Args>(args)...)
-  } -> std::same_as<bool>;
-};
+concept ActorHasAct =
+    ActorHasActWithoutResult<actor_t, propagator_state_t, stepper_t,
+                             navigator_t, Args...> ||
+    ActorHasActWithResult<actor_t, propagator_state_t, stepper_t, navigator_t,
+                          Args...>;
 
 template <typename actor_t, typename propagator_state_t, typename stepper_t,
           typename navigator_t, typename... Args>
@@ -71,35 +59,29 @@ concept ActorHasAbortWithoutResult = requires(
 
 template <typename actor_t, typename propagator_state_t, typename stepper_t,
           typename navigator_t, typename... Args>
-concept ActorHasAbort =
-    (!ActorHasResult<actor_t> &&
-     ActorHasAbortWithoutResult<actor_t, propagator_state_t, stepper_t,
-                                navigator_t, Args...>) ||
-    (ActorHasResult<actor_t> &&
-     ActorHasAbortWithResult<actor_t, propagator_state_t, stepper_t,
-                             navigator_t, Args...>);
+concept ActorHasAbortWithResult =
+    ActorHasResult<actor_t> &&
+    requires(const actor_t& a, propagator_state_t& state,
+             const stepper_t& stepper, const navigator_t& navigator,
+             typename actor_t::result_type& result, Args&&... args) {
+      {
+        a.checkAbort(state, stepper, navigator, result,
+                     std::forward<Args>(args)...)
+      } -> std::same_as<bool>;
+    };
 
 template <typename actor_t, typename propagator_state_t, typename stepper_t,
           typename navigator_t, typename... Args>
-concept ActorHasActAndAbort =
-    (!ActorHasResult<actor_t> &&
-     ActorHasActWithoutResult<actor_t, propagator_state_t, stepper_t,
-                              navigator_t, Args...> &&
-     ActorHasAbortWithoutResult<actor_t, propagator_state_t, stepper_t,
-                                navigator_t, Args...>) ||
-    (ActorHasResult<actor_t> &&
-     ActorHasActWithResult<actor_t, propagator_state_t, stepper_t, navigator_t,
-                           Args...> &&
-     ActorHasAbortWithResult<actor_t, propagator_state_t, stepper_t,
-                             navigator_t, Args...>);
+concept ActorHasAbort =
+    ActorHasAbortWithoutResult<actor_t, propagator_state_t, stepper_t,
+                               navigator_t, Args...> ||
+    ActorHasAbortWithResult<actor_t, propagator_state_t, stepper_t, navigator_t,
+                            Args...>;
 
 template <typename actor_t, typename propagator_state_t, typename stepper_t,
           typename navigator_t, typename... Args>
 concept Actor =
     ActorHasAct<actor_t, propagator_state_t, stepper_t, navigator_t, Args...> ||
-    ActorHasAbort<actor_t, propagator_state_t, stepper_t, navigator_t,
-                  Args...> ||
-    ActorHasActAndAbort<actor_t, propagator_state_t, stepper_t, navigator_t,
-                        Args...>;
+    ActorHasAbort<actor_t, propagator_state_t, stepper_t, navigator_t, Args...>;
 
 }  // namespace Acts
diff --git a/Core/include/Acts/Propagator/ActorList.hpp b/Core/include/Acts/Propagator/ActorList.hpp
index fa02e6597dd..1101caf2682 100644
--- a/Core/include/Acts/Propagator/ActorList.hpp
+++ b/Core/include/Acts/Propagator/ActorList.hpp
@@ -26,22 +26,12 @@ 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...>)
 struct ActorList {
- private:
-  static_assert(
-      detail::all_of_v<std::is_default_constructible<actors_t>::value...>,
-      "all actors must be default constructible");
-  static_assert(
-      detail::all_of_v<std::is_copy_constructible<actors_t>::value...>,
-      "all actors must be copy constructible");
-  static_assert(
-      detail::all_of_v<std::is_move_constructible<actors_t>::value...>,
-      "all actors must be move constructible");
-
-  static_assert(!detail::has_duplicates_v<actors_t...>,
-                "same action type specified several times");
-
- public:
   /// @cond
   // This uses the type collector and unpacks using the `R` meta function
   template <template <typename...> class R>
diff --git a/Core/include/Acts/TrackFitting/KalmanFitter.hpp b/Core/include/Acts/TrackFitting/KalmanFitter.hpp
index 59ab432f360..8f73bcc199e 100644
--- a/Core/include/Acts/TrackFitting/KalmanFitter.hpp
+++ b/Core/include/Acts/TrackFitting/KalmanFitter.hpp
@@ -506,10 +506,7 @@ class KalmanFitter {
     bool checkAbort(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
                     const navigator_t& /*navigator*/, const result_type& result,
                     const Logger& /*logger*/) const {
-      if (!result.result.ok() || result.finished) {
-        return true;
-      }
-      return false;
+      return (!result.result.ok() || result.finished);
     }
 
     /// @brief Kalman actor operation: reverse direction

From a5c3a596e593a1a4d78b9cedeb14e4d6c65aa4c9 Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Wed, 11 Sep 2024 08:28:31 +0200
Subject: [PATCH 14/15] simplify delegation

---
 .../detail/actor_list_implementation.hpp      | 44 ++++++++++---------
 1 file changed, 24 insertions(+), 20 deletions(-)

diff --git a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
index 69f4af768f5..0e406f561ba 100644
--- a/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
+++ b/Core/include/Acts/Propagator/detail/actor_list_implementation.hpp
@@ -27,15 +27,18 @@ struct actor_caller {
     requires(
         Actor<actor_t, propagator_state_t, stepper_t, navigator_t, Args...>)
   {
-    if constexpr (ActorHasAct<actor_t, propagator_state_t, stepper_t,
-                              navigator_t, Args...>) {
-      if constexpr (ActorHasResult<actor_t>) {
-        actor.act(state, stepper, navigator,
-                  state.template get<detail::result_type_t<actor_t>>(),
-                  std::forward<Args>(args)...);
-      } else {
-        actor.act(state, stepper, navigator, std::forward<Args>(args)...);
-      }
+    if constexpr (ActorHasActWithoutResult<actor_t, propagator_state_t,
+                                           stepper_t, navigator_t, Args...>) {
+      actor.act(state, stepper, navigator, std::forward<Args>(args)...);
+      return;
+    }
+
+    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>>(),
+                std::forward<Args>(args)...);
+      return;
     }
   }
 
@@ -47,17 +50,18 @@ struct actor_caller {
     requires(
         Actor<actor_t, propagator_state_t, stepper_t, navigator_t, Args...>)
   {
-    if constexpr (ActorHasAbort<actor_t, propagator_state_t, stepper_t,
-                                navigator_t, Args...>) {
-      if constexpr (ActorHasResult<actor_t>) {
-        return actor.checkAbort(
-            state, stepper, navigator,
-            state.template get<detail::result_type_t<actor_t>>(),
-            std::forward<Args>(args)...);
-      } else {
-        return actor.checkAbort(state, stepper, navigator,
-                                std::forward<Args>(args)...);
-      }
+    if constexpr (ActorHasAbortWithoutResult<actor_t, propagator_state_t,
+                                             stepper_t, navigator_t, Args...>) {
+      return actor.checkAbort(state, stepper, navigator,
+                              std::forward<Args>(args)...);
+    }
+
+    if constexpr (ActorHasAbortWithResult<actor_t, propagator_state_t,
+                                          stepper_t, navigator_t, Args...>) {
+      return actor.checkAbort(
+          state, stepper, navigator,
+          state.template get<detail::result_type_t<actor_t>>(),
+          std::forward<Args>(args)...);
     }
 
     return false;

From dadfbfe95d441789e40d40ab41d95b5067799721 Mon Sep 17 00:00:00 2001
From: Andreas Stefl <stefl.andreas@gmail.com>
Date: Thu, 12 Sep 2024 10:37:44 +0200
Subject: [PATCH 15/15] std::move

---
 Core/include/Acts/Propagator/ActorConcepts.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Core/include/Acts/Propagator/ActorConcepts.hpp b/Core/include/Acts/Propagator/ActorConcepts.hpp
index abbe1ae1d8a..d83119135ea 100644
--- a/Core/include/Acts/Propagator/ActorConcepts.hpp
+++ b/Core/include/Acts/Propagator/ActorConcepts.hpp
@@ -23,7 +23,7 @@ concept ActorHasActWithoutResult = requires(
     const actor_t& a, propagator_state_t& state, const stepper_t& stepper,
     const navigator_t& navigator, Args&&... args) {
   {
-    a.act(state, stepper, navigator, std::forward<Args>(args)...)
+    a.act(state, stepper, navigator, std::move<Args>(args)...)
   } -> std::same_as<void>;
 };
 
@@ -35,7 +35,7 @@ concept ActorHasActWithResult =
              const stepper_t& stepper, const navigator_t& navigator,
              typename actor_t::result_type& result, Args&&... args) {
       {
-        a.act(state, stepper, navigator, result, std::forward<Args>(args)...)
+        a.act(state, stepper, navigator, result, std::move<Args>(args)...)
       } -> std::same_as<void>;
     };
 
@@ -53,7 +53,7 @@ concept ActorHasAbortWithoutResult = requires(
     const actor_t& a, propagator_state_t& state, const stepper_t& stepper,
     const navigator_t& navigator, Args&&... args) {
   {
-    a.checkAbort(state, stepper, navigator, std::forward<Args>(args)...)
+    a.checkAbort(state, stepper, navigator, std::move<Args>(args)...)
   } -> std::same_as<bool>;
 };
 
@@ -66,7 +66,7 @@ concept ActorHasAbortWithResult =
              typename actor_t::result_type& result, Args&&... args) {
       {
         a.checkAbort(state, stepper, navigator, result,
-                     std::forward<Args>(args)...)
+                     std::move<Args>(args)...)
       } -> std::same_as<bool>;
     };