From 21b66336b5d60c226cae7f5844da865ef79c506b Mon Sep 17 00:00:00 2001
From: Trent Houliston <trent@houliston.me>
Date: Tue, 15 Oct 2024 16:06:32 +1100
Subject: [PATCH] Trying to pull out common code and allow for more flexibility
 in DSL words

---
 src/Reactor.hpp                               |   1 +
 src/dsl/Fusion.hpp                            |  95 +++++++++++---
 src/dsl/Parse.hpp                             |  52 ++++----
 src/dsl/fusion/BindFusion.hpp                 | 122 ------------------
 src/dsl/fusion/{has_pool.hpp => Fuse.hpp}     |  36 ++----
 src/dsl/fusion/GetFusion.hpp                  |  81 ------------
 src/dsl/fusion/GroupFusion.hpp                |  77 -----------
 src/dsl/fusion/InlineFusion.hpp               |  79 ------------
 src/dsl/fusion/NoOp.hpp                       |  16 ++-
 src/dsl/fusion/PoolFusion.hpp                 |  71 ----------
 src/dsl/fusion/PostconditionFusion.hpp        |  73 -----------
 src/dsl/fusion/PreconditionFusion.hpp         |  71 ----------
 src/dsl/fusion/PriorityFusion.hpp             |  71 ----------
 src/dsl/fusion/fusion/Caller.hpp              |  82 ++++++++++++
 src/dsl/fusion/{ => fusion}/FindWords.hpp     |  20 +--
 src/dsl/fusion/fusion/Fuser.hpp               |  72 +++++++++++
 src/dsl/fusion/fusion/is_dsl_word.hpp         |  47 +++++++
 src/dsl/fusion/has_postcondition.hpp          |  58 ---------
 src/dsl/fusion/has_precondition.hpp           |  58 ---------
 src/dsl/fusion/has_run_inline.hpp             |  58 ---------
 src/dsl/fusion/{has_get.hpp => hook/Bind.hpp} |  50 ++++---
 .../fusion/{has_priority.hpp => hook/Get.hpp} |  51 ++++----
 .../fusion/{has_group.hpp => hook/Group.hpp}  |  59 +++++----
 src/dsl/fusion/hook/Pool.hpp                  |  50 +++++++
 src/dsl/fusion/hook/PostRun.hpp               |  45 +++++++
 src/dsl/fusion/hook/PreRun.hpp                |  44 +++++++
 src/dsl/fusion/hook/Precondition.hpp          |  50 +++++++
 src/dsl/fusion/hook/Priority.hpp              |  50 +++++++
 .../{has_bind.hpp => hook/RunInline.hpp}      |  62 +++++----
 src/dsl/fusion/hook/Scope.hpp                 |  54 ++++++++
 src/dsl/validation/Validation.hpp             |   6 +-
 src/dsl/word/Always.hpp                       |   2 +-
 src/dsl/word/IO.hpp                           |   2 +-
 src/dsl/word/Idle.hpp                         |   1 -
 src/dsl/word/Once.hpp                         |   4 +-
 src/util/CallbackGenerator.hpp                |  11 +-
 36 files changed, 757 insertions(+), 1024 deletions(-)
 delete mode 100644 src/dsl/fusion/BindFusion.hpp
 rename src/dsl/fusion/{has_pool.hpp => Fuse.hpp} (60%)
 delete mode 100644 src/dsl/fusion/GetFusion.hpp
 delete mode 100644 src/dsl/fusion/GroupFusion.hpp
 delete mode 100644 src/dsl/fusion/InlineFusion.hpp
 delete mode 100644 src/dsl/fusion/PoolFusion.hpp
 delete mode 100644 src/dsl/fusion/PostconditionFusion.hpp
 delete mode 100644 src/dsl/fusion/PreconditionFusion.hpp
 delete mode 100644 src/dsl/fusion/PriorityFusion.hpp
 create mode 100644 src/dsl/fusion/fusion/Caller.hpp
 rename src/dsl/fusion/{ => fusion}/FindWords.hpp (73%)
 create mode 100644 src/dsl/fusion/fusion/Fuser.hpp
 create mode 100644 src/dsl/fusion/fusion/is_dsl_word.hpp
 delete mode 100644 src/dsl/fusion/has_postcondition.hpp
 delete mode 100644 src/dsl/fusion/has_precondition.hpp
 delete mode 100644 src/dsl/fusion/has_run_inline.hpp
 rename src/dsl/fusion/{has_get.hpp => hook/Bind.hpp} (58%)
 rename src/dsl/fusion/{has_priority.hpp => hook/Get.hpp} (58%)
 rename src/dsl/fusion/{has_group.hpp => hook/Group.hpp} (52%)
 create mode 100644 src/dsl/fusion/hook/Pool.hpp
 create mode 100644 src/dsl/fusion/hook/PostRun.hpp
 create mode 100644 src/dsl/fusion/hook/PreRun.hpp
 create mode 100644 src/dsl/fusion/hook/Precondition.hpp
 create mode 100644 src/dsl/fusion/hook/Priority.hpp
 rename src/dsl/fusion/{has_bind.hpp => hook/RunInline.hpp} (50%)
 create mode 100644 src/dsl/fusion/hook/Scope.hpp

diff --git a/src/Reactor.hpp b/src/Reactor.hpp
index d21740d5..aea640f3 100644
--- a/src/Reactor.hpp
+++ b/src/Reactor.hpp
@@ -33,6 +33,7 @@
 #include "Environment.hpp"
 #include "LogLevel.hpp"
 #include "dsl/Parse.hpp"
+#include "dsl/word/Pool.hpp"
 #include "threading/Reaction.hpp"
 #include "threading/ReactionHandle.hpp"
 #include "threading/ReactionIdentifiers.hpp"
diff --git a/src/dsl/Fusion.hpp b/src/dsl/Fusion.hpp
index ab5ce5d9..3006d424 100644
--- a/src/dsl/Fusion.hpp
+++ b/src/dsl/Fusion.hpp
@@ -23,30 +23,87 @@
 #ifndef NUCLEAR_DSL_FUSION_HPP
 #define NUCLEAR_DSL_FUSION_HPP
 
-#include "../threading/ReactionHandle.hpp"
-#include "fusion/BindFusion.hpp"
-#include "fusion/GetFusion.hpp"
-#include "fusion/GroupFusion.hpp"
-#include "fusion/InlineFusion.hpp"
-#include "fusion/PoolFusion.hpp"
-#include "fusion/PostconditionFusion.hpp"
-#include "fusion/PreconditionFusion.hpp"
-#include "fusion/PriorityFusion.hpp"
+#include "fusion/Fuse.hpp"
+#include "fusion/hook/Bind.hpp"
+#include "fusion/hook/Get.hpp"
+#include "fusion/hook/Group.hpp"
+#include "fusion/hook/Pool.hpp"
+#include "fusion/hook/PostRun.hpp"
+#include "fusion/hook/PreRun.hpp"
+#include "fusion/hook/Precondition.hpp"
+#include "fusion/hook/Priority.hpp"
+#include "fusion/hook/RunInline.hpp"
+#include "fusion/hook/Scope.hpp"
+
 
 namespace NUClear {
 namespace dsl {
 
     /// All of the words from a reaction handle "fused" together into one type
-    template <typename... Words>
-    struct Fusion
-        : fusion::BindFusion<Words...>
-        , fusion::GetFusion<Words...>
-        , fusion::GroupFusion<Words...>
-        , fusion::InlineFusion<Words...>
-        , fusion::PreconditionFusion<Words...>
-        , fusion::PriorityFusion<Words...>
-        , fusion::PoolFusion<Words...>
-        , fusion::PostconditionFusion<Words...> {};
+    template <typename Word1, typename... WordN>
+    struct Fusion {
+
+        using BindFusion         = fusion::Fuse<fusion::hook::Bind, Word1, WordN...>;
+        using GetFusion          = fusion::Fuse<fusion::hook::Get, Word1, WordN...>;
+        using GroupFusion        = fusion::Fuse<fusion::hook::Group, Word1, WordN...>;
+        using PoolFusion         = fusion::Fuse<fusion::hook::Pool, Word1, WordN...>;
+        using PostRunFusion      = fusion::Fuse<fusion::hook::PostRun, Word1, WordN...>;
+        using PreRunFusion       = fusion::Fuse<fusion::hook::PreRun, Word1, WordN...>;
+        using PreconditionFusion = fusion::Fuse<fusion::hook::Precondition, Word1, WordN...>;
+        using PriorityFusion     = fusion::Fuse<fusion::hook::Priority, Word1, WordN...>;
+        using RunInlineFusion    = fusion::Fuse<fusion::hook::RunInline, Word1, WordN...>;
+        using ScopeFusion        = fusion::Fuse<fusion::hook::Scope, Word1, WordN...>;
+
+        template <typename DSL, typename... Args>
+        static auto bind(Args&&... args) -> decltype(BindFusion::call(std::forward<Args>(args)...)) {
+            return BindFusion::call(std::forward<Args>(args)...);
+        }
+
+        template <typename DSL, typename... Args>
+        static auto get(Args&&... args) -> decltype(GetFusion::call(std::forward<Args>(args)...)) {
+            return GetFusion::call(std::forward<Args>(args)...);
+        }
+
+        template <typename DSL, typename... Args>
+        static auto group(Args&&... args) -> decltype(GroupFusion::call(std::forward<Args>(args)...)) {
+            return GroupFusion::call(std::forward<Args>(args)...);
+        }
+
+        template <typename DSL, typename... Args>
+        static auto pool(Args&&... args) -> decltype(PoolFusion::call(std::forward<Args>(args)...)) {
+            return PoolFusion::call(std::forward<Args>(args)...);
+        }
+
+        template <typename DSL, typename... Args>
+        static auto post_run(Args&&... args) -> decltype(PostRunFusion::call(std::forward<Args>(args)...)) {
+            return PostRunFusion::call(std::forward<Args>(args)...);
+        }
+
+        template <typename DSL, typename... Args>
+        static auto pre_run(Args&&... args) -> decltype(PreRunFusion::call(std::forward<Args>(args)...)) {
+            return PreRunFusion::call(std::forward<Args>(args)...);
+        }
+
+        template <typename DSL, typename... Args>
+        static auto precondition(Args&&... args) -> decltype(PreconditionFusion::call(std::forward<Args>(args)...)) {
+            return PreconditionFusion::call(std::forward<Args>(args)...);
+        }
+
+        template <typename DSL, typename... Args>
+        static auto priority(Args&&... args) -> decltype(PriorityFusion::call(std::forward<Args>(args)...)) {
+            return PriorityFusion::call(std::forward<Args>(args)...);
+        }
+
+        template <typename DSL, typename... Args>
+        static auto run_inline(Args&&... args) -> decltype(RunInlineFusion::call(std::forward<Args>(args)...)) {
+            return RunInlineFusion::call(std::forward<Args>(args)...);
+        }
+
+        template <typename DSL, typename... Args>
+        static auto scope(Args&&... args) -> decltype(ScopeFusion::call(std::forward<Args>(args)...)) {
+            return ScopeFusion::call(std::forward<Args>(args)...);
+        }
+    };
 
 }  // namespace dsl
 }  // namespace NUClear
diff --git a/src/dsl/Parse.hpp b/src/dsl/Parse.hpp
index 58983ab8..1c811658 100644
--- a/src/dsl/Parse.hpp
+++ b/src/dsl/Parse.hpp
@@ -24,6 +24,7 @@
 #define NUCLEAR_DSL_PARSE_HPP
 
 #include "Fusion.hpp"
+#include "fusion/NoOp.hpp"
 #include "validation/Validation.hpp"
 
 namespace NUClear {
@@ -32,7 +33,7 @@ namespace dsl {
     template <typename... Sentence>
     struct Parse {
 
-        using DSL = Fusion<Sentence...>;
+        using DSL = Fusion<Sentence..., fusion::NoOp>;
 
         template <typename... Arguments>
         static auto bind(const std::shared_ptr<threading::Reaction>& r, Arguments&&... args)
@@ -40,41 +41,44 @@ namespace dsl {
             return DSL::template bind<Parse<Sentence...>>(r, std::forward<Arguments>(args)...);
         }
 
-        static auto get(threading::ReactionTask& task)
-            -> decltype(std::conditional_t<fusion::has_get<DSL>::value, DSL, fusion::NoOp>::template get<
-                        Parse<Sentence...>>(task)) {
-            return std::conditional_t<fusion::has_get<DSL>::value, DSL, fusion::NoOp>::template get<Parse<Sentence...>>(
-                task);
+        static auto get(threading::ReactionTask& task) -> decltype(DSL::template get<Parse<Sentence...>>(task)) {
+            return DSL::template get<Parse<Sentence...>>(task);
         }
 
-        static std::set<std::shared_ptr<const util::GroupDescriptor>> group(threading::ReactionTask& task) {
-            return std::conditional_t<fusion::has_group<DSL>::value, DSL, fusion::NoOp>::template group<
-                Parse<Sentence...>>(task);
+        static auto group(threading::ReactionTask& task) -> decltype(DSL::template group<Parse<Sentence...>>(task)) {
+            return DSL::template group<Parse<Sentence...>>(task);
         }
 
-        static util::Inline run_inline(threading::ReactionTask& task) {
-            return std::conditional_t<fusion::has_run_inline<DSL>::value, DSL, fusion::NoOp>::template run_inline<
-                Parse<Sentence...>>(task);
+        static auto pool(threading::ReactionTask& task) -> decltype(DSL::template pool<Parse<Sentence...>>(task)) {
+            return DSL::template pool<Parse<Sentence...>>(task);
         }
 
-        static bool precondition(threading::ReactionTask& task) {
-            return std::conditional_t<fusion::has_precondition<DSL>::value, DSL, fusion::NoOp>::template precondition<
-                Parse<Sentence...>>(task);
+        static auto postrun(threading::ReactionTask& task)
+            -> decltype(DSL::template postrun<Parse<Sentence...>>(task)) {
+            return DSL::template postrun<Parse<Sentence...>>(task);
         }
 
-        static int priority(threading::ReactionTask& task) {
-            return std::conditional_t<fusion::has_priority<DSL>::value, DSL, fusion::NoOp>::template priority<
-                Parse<Sentence...>>(task);
+        static auto prerun(threading::ReactionTask& task) -> decltype(DSL::template prerun<Parse<Sentence...>>(task)) {
+            return DSL::template prerun<Parse<Sentence...>>(task);
         }
 
-        static std::shared_ptr<const util::ThreadPoolDescriptor> pool(threading::ReactionTask& task) {
-            return std::conditional_t<fusion::has_pool<DSL>::value, DSL, fusion::NoOp>::template pool<
-                Parse<Sentence...>>(task);
+        static auto precondition(threading::ReactionTask& task)
+            -> decltype(DSL::template precondition<Parse<Sentence...>>(task)) {
+            return DSL::template precondition<Parse<Sentence...>>(task);
         }
 
-        static void postcondition(threading::ReactionTask& task) {
-            std::conditional_t<fusion::has_postcondition<DSL>::value, DSL, fusion::NoOp>::template postcondition<
-                Parse<Sentence...>>(task);
+        static auto priority(threading::ReactionTask& task)
+            -> decltype(DSL::template priority<Parse<Sentence...>>(task)) {
+            return DSL::template priority<Parse<Sentence...>>(task);
+        }
+
+        static auto run_inline(threading::ReactionTask& task)
+            -> decltype(DSL::template run_inline<Parse<Sentence...>>(task)) {
+            return DSL::template run_inline<Parse<Sentence...>>(task);
+        }
+
+        static auto scope(threading::ReactionTask& task) -> decltype(DSL::template scope<Parse<Sentence...>>(task)) {
+            return DSL::template scope<Parse<Sentence...>>(task);
         }
     };
 
diff --git a/src/dsl/fusion/BindFusion.hpp b/src/dsl/fusion/BindFusion.hpp
deleted file mode 100644
index f93a68c8..00000000
--- a/src/dsl/fusion/BindFusion.hpp
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2014 NUClear Contributors
- *
- * This file is part of the NUClear codebase.
- * See https://github.com/Fastcode/NUClear for further info.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
- * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef NUCLEAR_DSL_FUSION_BIND_FUSION_HPP
-#define NUCLEAR_DSL_FUSION_BIND_FUSION_HPP
-
-#include "../../threading/Reaction.hpp"
-#include "../../util/FunctionFusion.hpp"
-#include "../operation/DSLProxy.hpp"
-#include "FindWords.hpp"
-#include "has_bind.hpp"
-
-namespace NUClear {
-namespace dsl {
-    namespace fusion {
-
-        /**
-         * This is our Function Fusion wrapper class that allows it to call bind functions.
-         *
-         * @tparam Function the bind function that we are wrapping for
-         * @tparam DSL      the DSL that we pass to our bind function
-         */
-        template <typename Function, typename DSL>
-        struct BindCaller {
-
-            /**
-             * This struct is used if there is a return type.
-             * It just passes the returned data back up.
-             *
-             * @return the data that is returned by the bind call
-             */
-            struct Return {
-                template <typename... Arguments>
-                static auto call(const std::shared_ptr<threading::Reaction>& reaction, Arguments&&... args) {
-                    return Function::template bind<DSL>(reaction, std::forward<Arguments>(args)...);
-                }
-            };
-
-            /**
-             * This struct is used if the return type of the bind function is void.
-             * It wraps it into an empty tuple instead.
-             *
-             * @return an empty tuple
-             */
-            struct NoReturn {
-                template <typename... Arguments>
-                static std::tuple<> call(const std::shared_ptr<threading::Reaction>& reaction, Arguments&&... args) {
-                    Function::template bind<DSL>(reaction, std::forward<Arguments>(args)...);
-                    return {};
-                }
-            };
-
-
-            template <typename... Arguments>
-            static auto call(const std::shared_ptr<threading::Reaction>& reaction, Arguments&&... args)
-                -> decltype(std::conditional_t<std::is_void<decltype(Function::template bind<DSL>(
-                                                   reaction,
-                                                   std::forward<Arguments>(args)...))>::value,
-                                               NoReturn,
-                                               Return>::template call(reaction, std::forward<Arguments>(args)...)) {
-
-                return std::conditional_t<
-                    std::is_void<decltype(Function::template bind<DSL>(reaction,
-                                                                       std::forward<Arguments>(args)...))>::value,
-                    NoReturn,
-                    Return>::template call(reaction, std::forward<Arguments>(args)...);
-            }
-        };
-
-        // Default case where there are no bind words
-        template <typename Words>
-        struct BindFuser {};
-
-        // Case where there is at least one bind word
-        template <typename Word1, typename... WordN>
-        struct BindFuser<std::tuple<Word1, WordN...>> {
-
-            template <typename DSL, typename... Arguments>
-            static auto bind(const std::shared_ptr<threading::Reaction>& reaction, Arguments&&... args)
-                -> decltype(util::FunctionFusion<std::tuple<Word1, WordN...>,
-                                                 decltype(std::forward_as_tuple(reaction,
-                                                                                std::forward<Arguments>(args)...)),
-                                                 BindCaller,
-                                                 std::tuple<DSL>,
-                                                 1>::call(reaction, std::forward<Arguments>(args)...)) {
-
-                // Perform our function fusion
-                return util::FunctionFusion<std::tuple<Word1, WordN...>,
-                                            decltype(std::forward_as_tuple(reaction, std::forward<Arguments>(args)...)),
-                                            BindCaller,
-                                            std::tuple<DSL>,
-                                            1>::call(reaction, std::forward<Arguments>(args)...);
-            }
-        };
-
-        template <typename Word1, typename... WordN>
-        struct BindFusion : BindFuser<FindWords<has_bind, Word1, WordN...>> {};
-
-    }  // namespace fusion
-}  // namespace dsl
-}  // namespace NUClear
-
-#endif  // NUCLEAR_DSL_FUSION_BIND_FUSION_HPP
diff --git a/src/dsl/fusion/has_pool.hpp b/src/dsl/fusion/Fuse.hpp
similarity index 60%
rename from src/dsl/fusion/has_pool.hpp
rename to src/dsl/fusion/Fuse.hpp
index 2f5c81e0..ba62d8e6 100644
--- a/src/dsl/fusion/has_pool.hpp
+++ b/src/dsl/fusion/Fuse.hpp
@@ -20,39 +20,25 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_FUSION_HAS_POOL_HPP
-#define NUCLEAR_DSL_FUSION_HAS_POOL_HPP
+#ifndef NUCLEAR_DSL_FUSION_FUSE_HPP
+#define NUCLEAR_DSL_FUSION_FUSE_HPP
 
-#include "../../threading/ReactionTask.hpp"
-#include "NoOp.hpp"
+#include <algorithm>
+#include <stdexcept>
+
+#include "fusion/FindWords.hpp"
+#include "fusion/Fuser.hpp"
+#include "fusion/is_dsl_word.hpp"
 
 namespace NUClear {
 namespace dsl {
     namespace fusion {
 
-        /**
-         * SFINAE struct to test if the passed class has a pool function that conforms to the NUClear DSL.
-         *
-         * @tparam T the class to check
-         */
-        template <typename T>
-        struct has_pool {
-        private:
-            using yes = std::true_type;
-            using no  = std::false_type;
-
-            template <typename U>
-            static auto test(int) -> decltype(U::template pool<ParsedNoOp>(std::declval<threading::ReactionTask&>()),
-                                              yes());
-            template <typename>
-            static no test(...);
-
-        public:
-            static constexpr bool value = std::is_same<decltype(test<T>(0)), yes>::value;
-        };
+        template <template <typename> class Hook, typename Word1, typename... WordN>
+        using Fuse = Fuser<Hook, FindWords<Hook, Word1, WordN...>>;
 
     }  // namespace fusion
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_FUSION_HAS_POOL_HPP
+#endif  // NUCLEAR_DSL_FUSION_FUSE_HPP
diff --git a/src/dsl/fusion/GetFusion.hpp b/src/dsl/fusion/GetFusion.hpp
deleted file mode 100644
index 9bbffe7f..00000000
--- a/src/dsl/fusion/GetFusion.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2014 NUClear Contributors
- *
- * This file is part of the NUClear codebase.
- * See https://github.com/Fastcode/NUClear for further info.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
- * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef NUCLEAR_DSL_FUSION_GET_FUSION_HPP
-#define NUCLEAR_DSL_FUSION_GET_FUSION_HPP
-
-#include "../../threading/Reaction.hpp"
-#include "../../util/tuplify.hpp"
-#include "../operation/DSLProxy.hpp"
-#include "FindWords.hpp"
-#include "has_get.hpp"
-
-namespace NUClear {
-namespace dsl {
-    namespace fusion {
-
-        /**
-         * This is our Function Fusion wrapper class that allows it to call get functions.
-         *
-         * @tparam Function the get function that we are wrapping for
-         * @tparam DSL      the DSL that we pass to our get function
-         */
-        template <typename Function, typename DSL>
-        struct GetCaller {
-            static auto call(threading::ReactionTask& task) -> decltype(Function::template get<DSL>(task)) {
-                return Function::template get<DSL>(task);
-            }
-        };
-
-        // Default case where there are no get words
-        template <typename Words>
-        struct GetFuser {};
-
-        // Case where there is at least one get word
-        template <typename Word1, typename... WordN>
-        struct GetFuser<std::tuple<Word1, WordN...>> {
-
-            template <typename DSL, typename U = Word1>
-            static auto get(threading::ReactionTask& task)
-                -> decltype(util::FunctionFusion<std::tuple<Word1, WordN...>,
-                                                 decltype(std::forward_as_tuple(task)),
-                                                 GetCaller,
-                                                 std::tuple<DSL>,
-                                                 1>::call(task)) {
-
-                // Perform our function fusion
-                return util::FunctionFusion<std::tuple<Word1, WordN...>,
-                                            decltype(std::forward_as_tuple(task)),
-                                            GetCaller,
-                                            std::tuple<DSL>,
-                                            1>::call(task);
-            }
-        };
-
-        template <typename Word1, typename... WordN>
-        struct GetFusion : GetFuser<FindWords<has_get, Word1, WordN...>> {};
-
-    }  // namespace fusion
-}  // namespace dsl
-}  // namespace NUClear
-
-#endif  // NUCLEAR_DSL_FUSION_GET_FUSION_HPP
diff --git a/src/dsl/fusion/GroupFusion.hpp b/src/dsl/fusion/GroupFusion.hpp
deleted file mode 100644
index e6668b54..00000000
--- a/src/dsl/fusion/GroupFusion.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2023 NUClear Contributors
- *
- * This file is part of the NUClear codebase.
- * See https://github.com/Fastcode/NUClear for further info.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
- * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef NUCLEAR_DSL_FUSION_GROUP_FUSION_HPP
-#define NUCLEAR_DSL_FUSION_GROUP_FUSION_HPP
-
-#include <algorithm>
-#include <set>
-#include <stdexcept>
-
-#include "../../threading/Reaction.hpp"
-#include "../operation/DSLProxy.hpp"
-#include "FindWords.hpp"
-#include "has_group.hpp"
-
-namespace NUClear {
-namespace dsl {
-    namespace fusion {
-
-        // Default case where there are no group words
-        template <typename Words>
-        struct GroupFuser {};
-
-        // Case where there is only a single word remaining
-        template <typename Word>
-        struct GroupFuser<std::tuple<Word>> {
-
-            template <typename DSL>
-            static std::set<std::shared_ptr<const util::GroupDescriptor>> group(threading::ReactionTask& task) {
-
-                // Return our group
-                return Word::template group<DSL>(task);
-            }
-        };
-
-        // Case where there are 2 or more words remaining
-        template <typename Word1, typename Word2, typename... WordN>
-        struct GroupFuser<std::tuple<Word1, Word2, WordN...>> {
-
-            template <typename DSL>
-            static std::set<std::shared_ptr<const util::GroupDescriptor>> group(threading::ReactionTask& task) {
-                // Merge the list of groups together
-                std::set<std::shared_ptr<const util::GroupDescriptor>> groups = Word1::template group<DSL>(task);
-                auto remainder = GroupFuser<std::tuple<Word2, WordN...>>::template group<DSL>(task);
-                groups.insert(remainder.begin(), remainder.end());
-
-                return groups;
-            }
-        };
-
-        template <typename Word1, typename... WordN>
-        struct GroupFusion : GroupFuser<FindWords<has_group, Word1, WordN...>> {};
-
-    }  // namespace fusion
-}  // namespace dsl
-}  // namespace NUClear
-
-#endif  // NUCLEAR_DSL_FUSION_GROUP_FUSION_HPP
diff --git a/src/dsl/fusion/InlineFusion.hpp b/src/dsl/fusion/InlineFusion.hpp
deleted file mode 100644
index c73884e1..00000000
--- a/src/dsl/fusion/InlineFusion.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2014 NUClear Contributors
- *
- * This file is part of the NUClear codebase.
- * See https://github.com/Fastcode/NUClear for further info.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
- * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef NUCLEAR_DSL_FUSION_INLINABLE_FUSION_HPP
-#define NUCLEAR_DSL_FUSION_INLINABLE_FUSION_HPP
-
-#include "../../threading/ReactionTask.hpp"
-#include "../../util/Inline.hpp"
-#include "../operation/DSLProxy.hpp"
-#include "FindWords.hpp"
-#include "has_run_inline.hpp"
-
-namespace NUClear {
-namespace dsl {
-    namespace fusion {
-
-        // Default case where there are no Inline words
-        template <typename Words>
-        struct InlineFuser {};
-
-        // Case where there is only a single word remaining
-        template <typename Word>
-        struct InlineFuser<std::tuple<Word>> {
-
-            template <typename DSL>
-            static util::Inline run_inline(threading::ReactionTask& task) {
-
-                // Run our remaining run_inline
-                return Word::template run_inline<DSL>(task);
-            }
-        };
-
-        // Case where there is more 2 more more words remaining
-        template <typename Word1, typename Word2, typename... WordN>
-        struct InlineFuser<std::tuple<Word1, Word2, WordN...>> {
-
-            template <typename DSL>
-            static util::Inline run_inline(threading::ReactionTask& task) {
-                auto a = Word1::template run_inline<DSL>(task);
-                auto b = InlineFuser<std::tuple<Word2, WordN...>>::template run_inline<DSL>(task);
-
-                // Must agree or make a choice
-                if ((a == util::Inline::ALWAYS && b == util::Inline::NEVER)
-                    || (a == util::Inline::NEVER && b == util::Inline::ALWAYS)) {
-                    throw std::logic_error("Cannot both always and never inline a reaction");
-                }
-
-                // Otherwise return the one that made a choice
-                return a == util::Inline::NEUTRAL ? b : a;
-            }
-        };
-
-        template <typename Word1, typename... WordN>
-        struct InlineFusion : InlineFuser<FindWords<has_run_inline, Word1, WordN...>> {};
-
-    }  // namespace fusion
-}  // namespace dsl
-}  // namespace NUClear
-
-#endif  // NUCLEAR_DSL_FUSION_INLINABLE_FUSION_HPP
diff --git a/src/dsl/fusion/NoOp.hpp b/src/dsl/fusion/NoOp.hpp
index 7ee1d03e..e8d107f9 100644
--- a/src/dsl/fusion/NoOp.hpp
+++ b/src/dsl/fusion/NoOp.hpp
@@ -80,7 +80,17 @@ namespace dsl {
             }
 
             template <typename DSL>
-            static void postcondition(const threading::ReactionTask& /*task*/) {
+            static void post_run(const threading::ReactionTask& /*task*/) {
+                // Empty as this is a no-op placeholder
+            }
+
+            template <typename DSL>
+            static void pre_run(const threading::ReactionTask& /*task*/) {
+                // Empty as this is a no-op placeholder
+            }
+
+            template <typename DSL>
+            static void scope(const threading::ReactionTask& /*task*/) {
                 // Empty as this is a no-op placeholder
             }
         };
@@ -106,7 +116,9 @@ namespace dsl {
 
             static std::shared_ptr<const util::ThreadPoolDescriptor> pool(threading::ReactionTask&);
 
-            static void postcondition(threading::ReactionTask&);
+            static void pre_run(threading::ReactionTask&);
+
+            static void post_run(threading::ReactionTask&);
         };
 
     }  // namespace fusion
diff --git a/src/dsl/fusion/PoolFusion.hpp b/src/dsl/fusion/PoolFusion.hpp
deleted file mode 100644
index 578b6e8d..00000000
--- a/src/dsl/fusion/PoolFusion.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2023 NUClear Contributors
- *
- * This file is part of the NUClear codebase.
- * See https://github.com/Fastcode/NUClear for further info.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
- * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef NUCLEAR_DSL_FUSION_POOL_FUSION_HPP
-#define NUCLEAR_DSL_FUSION_POOL_FUSION_HPP
-
-#include <algorithm>
-#include <stdexcept>
-
-#include "../../threading/ReactionTask.hpp"
-#include "../operation/DSLProxy.hpp"
-#include "FindWords.hpp"
-#include "has_pool.hpp"
-
-namespace NUClear {
-namespace dsl {
-    namespace fusion {
-
-        // Default case where there are no pool words
-        template <typename Words>
-        struct PoolFuser {};
-
-        // Case where there is only a single word remaining
-        template <typename Word>
-        struct PoolFuser<std::tuple<Word>> {
-
-            template <typename DSL>
-            static std::shared_ptr<const util::ThreadPoolDescriptor> pool(threading::ReactionTask& task) {
-
-                // Return our pool
-                return Word::template pool<DSL>(task);
-            }
-        };
-
-        // Case where there are 2 or more words remaining
-        template <typename Word1, typename Word2, typename... WordN>
-        struct PoolFuser<std::tuple<Word1, Word2, WordN...>> {
-
-            template <typename DSL>
-            static util::ThreadPoolDescriptor pool(const threading::ReactionTask& /*task*/) {
-                throw std::invalid_argument("Can not be a member of more than one pool");
-            }
-        };
-
-        template <typename Word1, typename... WordN>
-        struct PoolFusion : PoolFuser<FindWords<has_pool, Word1, WordN...>> {};
-
-    }  // namespace fusion
-}  // namespace dsl
-}  // namespace NUClear
-
-#endif  // NUCLEAR_DSL_FUSION_POOL_FUSION_HPP
diff --git a/src/dsl/fusion/PostconditionFusion.hpp b/src/dsl/fusion/PostconditionFusion.hpp
deleted file mode 100644
index 3eeb9aac..00000000
--- a/src/dsl/fusion/PostconditionFusion.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2014 NUClear Contributors
- *
- * This file is part of the NUClear codebase.
- * See https://github.com/Fastcode/NUClear for further info.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
- * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef NUCLEAR_DSL_FUSION_POSTCONDITION_FUSION_HPP
-#define NUCLEAR_DSL_FUSION_POSTCONDITION_FUSION_HPP
-
-#include "../../threading/ReactionTask.hpp"
-#include "../operation/DSLProxy.hpp"
-#include "FindWords.hpp"
-#include "has_postcondition.hpp"
-
-namespace NUClear {
-namespace dsl {
-    namespace fusion {
-
-        // Default case where there are no postcondition words
-        template <typename Words>
-        struct PostconditionFuser {};
-
-        // Case where there is only a single word remaining
-        template <typename Word>
-        struct PostconditionFuser<std::tuple<Word>> {
-
-            template <typename DSL>
-            static void postcondition(threading::ReactionTask& task) {
-
-                // Run our remaining postcondition
-                Word::template postcondition<DSL>(task);
-            }
-        };
-
-        // Case where there is more 2 more more words remaining
-        template <typename Word1, typename Word2, typename... WordN>
-        struct PostconditionFuser<std::tuple<Word1, Word2, WordN...>> {
-
-            template <typename DSL>
-            static void postcondition(threading::ReactionTask& task) {
-
-                // Run our postcondition
-                Word1::template postcondition<DSL>(task);
-
-                // Run the rest of our postconditions
-                PostconditionFuser<std::tuple<Word2, WordN...>>::template postcondition<DSL>(task);
-            }
-        };
-
-        template <typename Word1, typename... WordN>
-        struct PostconditionFusion : PostconditionFuser<FindWords<has_postcondition, Word1, WordN...>> {};
-
-    }  // namespace fusion
-}  // namespace dsl
-}  // namespace NUClear
-
-#endif  // NUCLEAR_DSL_FUSION_POSTCONDITION_FUSION_HPP
diff --git a/src/dsl/fusion/PreconditionFusion.hpp b/src/dsl/fusion/PreconditionFusion.hpp
deleted file mode 100644
index 09d0b696..00000000
--- a/src/dsl/fusion/PreconditionFusion.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2014 NUClear Contributors
- *
- * This file is part of the NUClear codebase.
- * See https://github.com/Fastcode/NUClear for further info.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
- * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef NUCLEAR_DSL_FUSION_PRECONDITION_FUSION_HPP
-#define NUCLEAR_DSL_FUSION_PRECONDITION_FUSION_HPP
-
-#include "../../threading/ReactionTask.hpp"
-#include "../operation/DSLProxy.hpp"
-#include "FindWords.hpp"
-#include "has_precondition.hpp"
-
-namespace NUClear {
-namespace dsl {
-    namespace fusion {
-
-        // Default case where there are no precondition words
-        template <typename Words>
-        struct PreconditionFuser {};
-
-        // Case where there is only a single word remaining
-        template <typename Word>
-        struct PreconditionFuser<std::tuple<Word>> {
-
-            template <typename DSL>
-            static bool precondition(threading::ReactionTask& task) {
-
-                // Run our remaining precondition
-                return Word::template precondition<DSL>(task);
-            }
-        };
-
-        // Case where there is more 2 more more words remaining
-        template <typename Word1, typename Word2, typename... WordN>
-        struct PreconditionFuser<std::tuple<Word1, Word2, WordN...>> {
-
-            template <typename DSL>
-            static bool precondition(threading::ReactionTask& task) {
-
-                // Perform a recursive and operation ending with the first false
-                return Word1::template precondition<DSL>(task)
-                       && PreconditionFuser<std::tuple<Word2, WordN...>>::template precondition<DSL>(task);
-            }
-        };
-
-        template <typename Word1, typename... WordN>
-        struct PreconditionFusion : PreconditionFuser<FindWords<has_precondition, Word1, WordN...>> {};
-
-    }  // namespace fusion
-}  // namespace dsl
-}  // namespace NUClear
-
-#endif  // NUCLEAR_DSL_FUSION_PRECONDITION_FUSION_HPP
diff --git a/src/dsl/fusion/PriorityFusion.hpp b/src/dsl/fusion/PriorityFusion.hpp
deleted file mode 100644
index 5000f9ae..00000000
--- a/src/dsl/fusion/PriorityFusion.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2015 NUClear Contributors
- *
- * This file is part of the NUClear codebase.
- * See https://github.com/Fastcode/NUClear for further info.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
- * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef NUCLEAR_DSL_FUSION_PRIORITY_FUSION_HPP
-#define NUCLEAR_DSL_FUSION_PRIORITY_FUSION_HPP
-
-#include "../../threading/ReactionTask.hpp"
-#include "../operation/DSLProxy.hpp"
-#include "FindWords.hpp"
-#include "has_priority.hpp"
-
-namespace NUClear {
-namespace dsl {
-    namespace fusion {
-
-        // Default case where there are no priority words
-        template <typename Words>
-        struct PriorityFuser {};
-
-        // Case where there is only a single word remaining
-        template <typename Word>
-        struct PriorityFuser<std::tuple<Word>> {
-
-            template <typename DSL>
-            static int priority(threading::ReactionTask& task) {
-
-                // Return our priority
-                return Word::template priority<DSL>(task);
-            }
-        };
-
-        // Case where there is more 2 more more words remaining
-        template <typename Word1, typename Word2, typename... WordN>
-        struct PriorityFuser<std::tuple<Word1, Word2, WordN...>> {
-
-            template <typename DSL>
-            static int priority(threading::ReactionTask& task) {
-
-                // Choose our maximum priority
-                return std::max(Word1::template priority<DSL>(task),
-                                PriorityFuser<std::tuple<Word2, WordN...>>::template priority<DSL>(task));
-            }
-        };
-
-        template <typename Word1, typename... WordN>
-        struct PriorityFusion : PriorityFuser<FindWords<has_priority, Word1, WordN...>> {};
-
-    }  // namespace fusion
-}  // namespace dsl
-}  // namespace NUClear
-
-#endif  // NUCLEAR_DSL_FUSION_PRIORITY_FUSION_HPP
diff --git a/src/dsl/fusion/fusion/Caller.hpp b/src/dsl/fusion/fusion/Caller.hpp
new file mode 100644
index 00000000..f2d81604
--- /dev/null
+++ b/src/dsl/fusion/fusion/Caller.hpp
@@ -0,0 +1,82 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2024 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef NUCLEAR_DSL_FUSION_FUSION_CALLER_HPP
+#define NUCLEAR_DSL_FUSION_FUSION_CALLER_HPP
+
+#include <algorithm>
+#include <stdexcept>
+
+#include "../../../threading/ReactionTask.hpp"
+
+namespace NUClear {
+namespace dsl {
+    namespace fusion {
+
+        /**
+         * Wraps the word such that we can call one of a set of options based on what arguments they take.
+         *
+         * @tparam Hook the template type which wraps a specific hook
+         */
+        template <template <typename> class Hook>
+        struct Caller {
+            // Call giving a reference to the ReactionTask
+            template <typename Word, typename DSL, typename... Args>
+            static auto call(threading::ReactionTask& task, Args&&... args)
+                -> decltype(Hook<Word>::template call<DSL>(task, std::forward<Args>(args)...)) {
+                return Hook<Word>::template call<DSL>(task, std::forward<Args>(args)...);
+            }
+
+            // Call giving a reference to the Reaction
+            template <typename Word, typename DSL, typename... Args>
+            static auto call(threading::ReactionTask& task, Args&&... args)
+                -> decltype(Hook<Word>::template call<DSL>(*task.parent, std::forward<Args>(args)...)) {
+                return Hook<Word>::template call<DSL>(*task.parent, std::forward<Args>(args)...);
+            }
+
+            // Call giving a shared_ptr to the Reaction
+            template <typename Word, typename DSL, typename... Args>
+            static auto call(threading::ReactionTask& task, Args&&... args)
+                -> decltype(Hook<Word>::template call<DSL>(task.parent, std::forward<Args>(args)...)) {
+                return Hook<Word>::template call<DSL>(task.parent, std::forward<Args>(args)...);
+            }
+
+            // Call giving a reference to the Reactor
+            template <typename Word, typename DSL, typename... Args>
+            static auto call(threading::ReactionTask& task, Args&&... args)
+                -> decltype(Hook<Word>::template call<DSL>(task.parent->reactor, std::forward<Args>(args)...)) {
+                return Hook<Word>::template call<DSL>(task.parent->reactor, std::forward<Args>(args)...);
+            }
+
+            // Call giving no additional arguments
+            template <typename Word, typename DSL, typename... Args>
+            static auto call(threading::ReactionTask& /*task*/, Args&&... args)
+                -> decltype(Hook<Word>::template call<DSL>(std::forward<Args>(args)...)) {
+                return Hook<Word>::template call<DSL>(std::forward<Args>(args)...);
+            }
+        };
+
+    }  // namespace fusion
+}  // namespace dsl
+}  // namespace NUClear
+
+#endif  // NUCLEAR_DSL_FUSION_FUSION_CALLER_HPP
diff --git a/src/dsl/fusion/FindWords.hpp b/src/dsl/fusion/fusion/FindWords.hpp
similarity index 73%
rename from src/dsl/fusion/FindWords.hpp
rename to src/dsl/fusion/fusion/FindWords.hpp
index 832cb363..93d39ba6 100644
--- a/src/dsl/fusion/FindWords.hpp
+++ b/src/dsl/fusion/fusion/FindWords.hpp
@@ -20,10 +20,12 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_FUSION_FIND_WORDS_HPP
-#define NUCLEAR_DSL_FUSION_FIND_WORDS_HPP
+#ifndef NUCLEAR_DSL_FUSION_FUSION_FIND_WORDS_HPP
+#define NUCLEAR_DSL_FUSION_FUSION_FIND_WORDS_HPP
 
-#include "../../util/meta/Filter.hpp"
+#include "../../../util/meta/Filter.hpp"
+#include "../../operation/DSLProxy.hpp"
+#include "is_dsl_word.hpp"
 
 namespace NUClear {
 namespace dsl {
@@ -37,14 +39,16 @@ namespace dsl {
          * - If the word does not have the correct function, it will try the DSLProxy for that word
          * - If neither have the correct function, it will remove the word from the list
          *
-         * @tparam Check The function to check for
-         * @tparam Ts    The words to check
+         * @tparam Hook  The hook to check for valid functions
+         * @tparam Words The words to check
          */
-        template <template <typename> class Check, typename... Ts>
-        using FindWords = Filter<Check, std::conditional_t<Check<Ts>::value, Ts, operation::DSLProxy<Ts>>...>;
+        template <template <typename> class Hook, typename... Words>
+        using FindWords = Filter<
+            is_dsl_word<Hook>::template check,
+            std::conditional_t<is_dsl_word<Hook>::template check<Words>::value, Words, operation::DSLProxy<Words>>...>;
 
     }  // namespace fusion
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_FUSION_FIND_WORDS_HPP
+#endif  // NUCLEAR_DSL_FUSION_FUSION_FIND_WORDS_HPP
diff --git a/src/dsl/fusion/fusion/Fuser.hpp b/src/dsl/fusion/fusion/Fuser.hpp
new file mode 100644
index 00000000..f9ed0248
--- /dev/null
+++ b/src/dsl/fusion/fusion/Fuser.hpp
@@ -0,0 +1,72 @@
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef NUCLEAR_DSL_FUSION_FUSION_FUSER_HPP
+#define NUCLEAR_DSL_FUSION_FUSION_FUSER_HPP
+
+#include <algorithm>
+#include <stdexcept>
+#include <tuple>
+
+#include "../../../threading/ReactionTask.hpp"
+#include "../../../util/tuplify.hpp"
+
+namespace NUClear {
+namespace dsl {
+    namespace fusion {
+
+        // Default case where there are no words
+        template <template <typename> class Hook, typename Words>
+        struct Fuser {};
+
+        // Case where there is only a single word remaining
+        template <template <typename> class Hook, typename Word>
+        struct Fuser<Hook, std::tuple<Word>> {
+
+            template <typename DSL, typename... Args>
+            static auto call(threading::ReactionTask& task, Args&&... args)
+                -> decltype(util::tuplify(Caller<Hook>::template call<Word, DSL>(task, std::forward<Args>(args)...))) {
+                return util::tuplify(Caller<Hook>::template call<Word, DSL>(task, std::forward<Args>(args)...));
+            }
+        };
+
+        // Case where there are 2 or more words remaining
+        template <template <typename> class Hook, typename Word1, typename... WordN>
+        struct Fuser<Hook, std::tuple<Word1, WordN...>> {
+
+            template <typename DSL, typename... Args>
+            static auto call(const threading::ReactionTask& task, Args&&... args)
+                -> decltype(util::tuplify(Hook<Word1>::template merge<DSL>(
+                    Fuser<Hook, std::tuple<Word1>>::call(task, std::forward<Args>(args)...),
+                    Fuser<Hook, std::tuple<WordN...>>::call(task, std::forward<Args>(args)...)))) {
+                return util::tuplify(Hook<Word1>::template merge<DSL>(
+                    Fuser<Hook, std::tuple<Word1>>::call(task, std::forward<Args>(args)...),
+                    Fuser<Hook, std::tuple<WordN...>>::call(task, std::forward<Args>(args)...)));
+            }
+        };
+
+    }  // namespace fusion
+}  // namespace dsl
+}  // namespace NUClear
+
+#endif  // NUCLEAR_DSL_FUSION_FUSION_FUSER_HPP
diff --git a/src/dsl/fusion/fusion/is_dsl_word.hpp b/src/dsl/fusion/fusion/is_dsl_word.hpp
new file mode 100644
index 00000000..ba8ea54c
--- /dev/null
+++ b/src/dsl/fusion/fusion/is_dsl_word.hpp
@@ -0,0 +1,47 @@
+
+#ifndef NUCLEAR_DSL_FUSION_FUSION_IS_DSL_WORD_HPP
+#define NUCLEAR_DSL_FUSION_FUSION_IS_DSL_WORD_HPP
+
+#include <tuple>
+#include <type_traits>
+
+#include "../../../threading/ReactionTask.hpp"
+#include "Caller.hpp"
+
+namespace NUClear {
+namespace dsl {
+    namespace fusion {
+
+        /**
+         * Determines if a given type is a DSL word for the given hook.
+         *
+         * @tparam Hook the template type which wraps a specific hook
+         * @tparam Word the type to check
+         */
+        template <template <typename> class Hook>
+        struct is_dsl_word {
+            template <typename Word>
+            struct check {
+            private:
+                using yes = std::true_type;
+                using no  = std::false_type;
+
+                template <typename R, typename... A>
+                static yes test_func(R (*)(threading::ReactionTask&, A...));
+                static no test_func(...);
+
+                template <typename U>
+                static auto test(int) -> decltype(test_func(Caller<Hook>::template call<U, void>));
+                template <typename>
+                static no test(...);
+
+            public:
+                static constexpr bool value = std::is_same<decltype(test<Word>(0)), yes>::value;
+            };
+        };
+
+    }  // namespace fusion
+}  // namespace dsl
+}  // namespace NUClear
+
+#endif  // NUCLEAR_DSL_FUSION_FUSION_IS_DSL_WORD_HPP
diff --git a/src/dsl/fusion/has_postcondition.hpp b/src/dsl/fusion/has_postcondition.hpp
deleted file mode 100644
index d782ab43..00000000
--- a/src/dsl/fusion/has_postcondition.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2014 NUClear Contributors
- *
- * This file is part of the NUClear codebase.
- * See https://github.com/Fastcode/NUClear for further info.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
- * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef NUCLEAR_DSL_FUSION_HAS_POSTCONDITION_HPP
-#define NUCLEAR_DSL_FUSION_HAS_POSTCONDITION_HPP
-
-#include "../../threading/ReactionTask.hpp"
-#include "NoOp.hpp"
-
-namespace NUClear {
-namespace dsl {
-    namespace fusion {
-
-        /**
-         * SFINAE struct to test if the passed class has a postcondition function that conforms to the NUClear DSL.
-         *
-         * @tparam T the class to check
-         */
-        template <typename T>
-        struct has_postcondition {
-        private:
-            using yes = std::true_type;
-            using no  = std::false_type;
-
-            template <typename U>
-            static auto test(int)
-                -> decltype(U::template postcondition<ParsedNoOp>(std::declval<threading::ReactionTask&>()), yes());
-            template <typename>
-            static no test(...);
-
-        public:
-            static constexpr bool value = std::is_same<decltype(test<T>(0)), yes>::value;
-        };
-
-    }  // namespace fusion
-}  // namespace dsl
-}  // namespace NUClear
-
-#endif  // NUCLEAR_DSL_FUSION_HAS_POSTCONDITION_HPP
diff --git a/src/dsl/fusion/has_precondition.hpp b/src/dsl/fusion/has_precondition.hpp
deleted file mode 100644
index 5fc22554..00000000
--- a/src/dsl/fusion/has_precondition.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2014 NUClear Contributors
- *
- * This file is part of the NUClear codebase.
- * See https://github.com/Fastcode/NUClear for further info.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
- * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef NUCLEAR_DSL_FUSION_HAS_PRECONDITION_HPP
-#define NUCLEAR_DSL_FUSION_HAS_PRECONDITION_HPP
-
-#include "../../threading/ReactionTask.hpp"
-#include "NoOp.hpp"
-
-namespace NUClear {
-namespace dsl {
-    namespace fusion {
-
-        /**
-         * SFINAE struct to test if the passed class has a precondition function that conforms to the NUClear DSL.
-         *
-         * @tparam T the class to check
-         */
-        template <typename T>
-        struct has_precondition {
-        private:
-            using yes = std::true_type;
-            using no  = std::false_type;
-
-            template <typename U>
-            static auto test(int)
-                -> decltype(U::template precondition<ParsedNoOp>(std::declval<threading::ReactionTask&>()), yes());
-            template <typename>
-            static no test(...);
-
-        public:
-            static constexpr bool value = std::is_same<decltype(test<T>(0)), yes>::value;
-        };
-
-    }  // namespace fusion
-}  // namespace dsl
-}  // namespace NUClear
-
-#endif  // NUCLEAR_DSL_FUSION_HAS_PRECONDITION_HPP
diff --git a/src/dsl/fusion/has_run_inline.hpp b/src/dsl/fusion/has_run_inline.hpp
deleted file mode 100644
index 3b24b583..00000000
--- a/src/dsl/fusion/has_run_inline.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2014 NUClear Contributors
- *
- * This file is part of the NUClear codebase.
- * See https://github.com/Fastcode/NUClear for further info.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
- * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef NUCLEAR_DSL_FUSION_HAS_RUN_INLINE_HPP
-#define NUCLEAR_DSL_FUSION_HAS_RUN_INLINE_HPP
-
-#include "../../threading/ReactionTask.hpp"
-#include "NoOp.hpp"
-
-namespace NUClear {
-namespace dsl {
-    namespace fusion {
-
-        /**
-         * SFINAE struct to test if the passed class has a run_inline function that conforms to the NUClear DSL.
-         *
-         * @tparam T the class to check
-         */
-        template <typename T>
-        struct has_run_inline {
-        private:
-            using yes = std::true_type;
-            using no  = std::false_type;
-
-            template <typename U>
-            static auto test(int)
-                -> decltype(U::template run_inline<ParsedNoOp>(std::declval<threading::ReactionTask&>()), yes());
-            template <typename>
-            static no test(...);
-
-        public:
-            static constexpr bool value = std::is_same<decltype(test<T>(0)), yes>::value;
-        };
-
-    }  // namespace fusion
-}  // namespace dsl
-}  // namespace NUClear
-
-#endif  // NUCLEAR_DSL_FUSION_HAS_RUN_INLINE_HPP
diff --git a/src/dsl/fusion/has_get.hpp b/src/dsl/fusion/hook/Bind.hpp
similarity index 58%
rename from src/dsl/fusion/has_get.hpp
rename to src/dsl/fusion/hook/Bind.hpp
index e07f2a76..78880e64 100644
--- a/src/dsl/fusion/has_get.hpp
+++ b/src/dsl/fusion/hook/Bind.hpp
@@ -19,40 +19,36 @@
  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+#ifndef NUCLEAR_DSL_FUSION_HOOK_BIND_HPP
+#define NUCLEAR_DSL_FUSION_HOOK_BIND_HPP
 
-#ifndef NUCLEAR_DSL_FUSION_HAS_GET_HPP
-#define NUCLEAR_DSL_FUSION_HAS_GET_HPP
+#include <tuple>
 
-#include "../../threading/ReactionTask.hpp"
-#include "NoOp.hpp"
+#include "../../../util/tuplify.hpp"
 
 namespace NUClear {
 namespace dsl {
     namespace fusion {
-
-        /**
-         * SFINAE struct to test if the passed class has a get function that conforms to the NUClear DSL.
-         *
-         * @tparam T the class to check
-         */
-        template <typename T>
-        struct has_get {
-        private:
-            using yes = std::true_type;
-            using no  = std::false_type;
-
-            template <typename U>
-            static auto test(int) -> decltype(U::template get<ParsedNoOp>(std::declval<threading::ReactionTask&>()),
-                                              yes());
-            template <typename>
-            static no test(...);
-
-        public:
-            static constexpr bool value = std::is_same<decltype(test<T>(0)), yes>::value;
-        };
-
+        namespace hook {
+
+            template <typename Word>
+            struct Bind {
+            public:
+                template <typename DSL, typename... Args>
+                static auto call(Args&&... args) -> decltype(Word::template bind<DSL>(std::forward<Args>(args)...)) {
+                    // TODO mark the pointer that we give to the bind function with the Word type
+                    return util::tuplify(Word::template bind<DSL>(std::forward<Args>(args)...));
+                }
+
+                template <typename DSL, typename LHS, typename RHS>
+                static auto merge(LHS&& lhs, RHS&& rhs) -> decltype(std::tuple_cat(lhs, rhs)) {
+                    return std::tuple_cat(lhs, rhs);
+                }
+            };
+
+        }  // namespace hook
     }  // namespace fusion
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_FUSION_HAS_GET_HPP
+#endif  // NUCLEAR_DSL_FUSION_HOOK_BIND_HPP
diff --git a/src/dsl/fusion/has_priority.hpp b/src/dsl/fusion/hook/Get.hpp
similarity index 58%
rename from src/dsl/fusion/has_priority.hpp
rename to src/dsl/fusion/hook/Get.hpp
index 6d97e01b..e8f50e75 100644
--- a/src/dsl/fusion/has_priority.hpp
+++ b/src/dsl/fusion/hook/Get.hpp
@@ -1,7 +1,7 @@
 /*
  * MIT License
  *
- * Copyright (c) 2014 NUClear Contributors
+ * Copyright (c) 2024 NUClear Contributors
  *
  * This file is part of the NUClear codebase.
  * See https://github.com/Fastcode/NUClear for further info.
@@ -19,40 +19,35 @@
  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+#ifndef NUCLEAR_DSL_FUSION_HOOK_GET_HPP
+#define NUCLEAR_DSL_FUSION_HOOK_GET_HPP
 
-#ifndef NUCLEAR_DSL_FUSION_HAS_PRIORITY_HPP
-#define NUCLEAR_DSL_FUSION_HAS_PRIORITY_HPP
+#include <tuple>
 
-#include "../../threading/ReactionTask.hpp"
-#include "NoOp.hpp"
+#include "../../../util/tuplify.hpp"
 
 namespace NUClear {
 namespace dsl {
     namespace fusion {
-
-        /**
-         * SFINAE struct to test if the passed class has a priority function that conforms to the NUClear DSL.
-         *
-         * @tparam T the class to check
-         */
-        template <typename T>
-        struct has_priority {
-        private:
-            using yes = std::true_type;
-            using no  = std::false_type;
-
-            template <typename U>
-            static auto test(int)
-                -> decltype(U::template priority<ParsedNoOp>(std::declval<threading::ReactionTask&>()), yes());
-            template <typename>
-            static no test(...);
-
-        public:
-            static constexpr bool value = std::is_same<decltype(test<T>(0)), yes>::value;
-        };
-
+        namespace hook {
+
+            template <typename Word>
+            struct Get {
+            public:
+                template <typename DSL, typename... Args>
+                static auto call(Args&&... args) -> decltype(Word::template get<DSL>(std::forward<Args>(args)...)) {
+                    return util::tuplify(Word::template get<DSL>(std::forward<Args>(args)...));
+                }
+
+                template <typename DSL, typename LHS, typename RHS>
+                static auto merge(LHS&& lhs, RHS&& rhs) -> decltype(std::tuple_cat(lhs, rhs)) {
+                    return std::tuple_cat(lhs, rhs);
+                }
+            };
+
+        }  // namespace hook
     }  // namespace fusion
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_FUSION_HAS_PRIORITY_HPP
+#endif  // NUCLEAR_DSL_FUSION_HOOK_GET_HPP
diff --git a/src/dsl/fusion/has_group.hpp b/src/dsl/fusion/hook/Group.hpp
similarity index 52%
rename from src/dsl/fusion/has_group.hpp
rename to src/dsl/fusion/hook/Group.hpp
index e5bf5071..f1ac28e9 100644
--- a/src/dsl/fusion/has_group.hpp
+++ b/src/dsl/fusion/hook/Group.hpp
@@ -1,7 +1,7 @@
 /*
  * MIT License
  *
- * Copyright (c) 2023 NUClear Contributors
+ * Copyright (c) 2024 NUClear Contributors
  *
  * This file is part of the NUClear codebase.
  * See https://github.com/Fastcode/NUClear for further info.
@@ -19,40 +19,43 @@
  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+#ifndef NUCLEAR_DSL_FUSION_HOOK_GROUP_HPP
+#define NUCLEAR_DSL_FUSION_HOOK_GROUP_HPP
 
-#ifndef NUCLEAR_DSL_FUSION_HAS_GROUP_HPP
-#define NUCLEAR_DSL_FUSION_HAS_GROUP_HPP
+#include <memory>
+#include <set>
 
-#include "../../threading/ReactionTask.hpp"
-#include "NoOp.hpp"
+#include "../../../util/GroupDescriptor.hpp"
 
 namespace NUClear {
 namespace dsl {
     namespace fusion {
-
-        /**
-         * SFINAE struct to test if the passed class has a group function that conforms to the NUClear DSL.
-         *
-         * @tparam T the class to check
-         */
-        template <typename T>
-        struct has_group {
-        private:
-            using yes = std::true_type;
-            using no  = std::false_type;
-
-            template <typename U>
-            static auto test(int) -> decltype(U::template group<ParsedNoOp>(std::declval<threading::ReactionTask&>()),
-                                              yes());
-            template <typename>
-            static no test(...);
-
-        public:
-            static constexpr bool value = std::is_same<decltype(test<T>(0)), yes>::value;
-        };
-
+        namespace hook {
+
+            template <typename Word>
+            struct Group {
+            private:
+                using GroupSet = std::set<std::shared_ptr<const util::GroupDescriptor>>;
+
+            public:
+                template <typename DSL, typename... Args>
+                static auto call(Args&&... args) -> decltype(Word::template group<DSL>(std::forward<Args>(args)...),
+                                                             std::declval<GroupSet>()) {
+                    return Word::template group<DSL>(std::forward<Args>(args)...);
+                }
+
+                template <typename DSL>
+                static GroupSet merge(const GroupSet& lhs, const GroupSet& rhs) {
+                    GroupSet groups;
+                    groups.insert(lhs.begin(), lhs.end());
+                    groups.insert(rhs.begin(), rhs.end());
+                    return groups;
+                }
+            };
+
+        }  // namespace hook
     }  // namespace fusion
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_FUSION_HAS_GROUP_HPP
+#endif  // NUCLEAR_DSL_FUSION_HOOK_GROUP_HPP
diff --git a/src/dsl/fusion/hook/Pool.hpp b/src/dsl/fusion/hook/Pool.hpp
new file mode 100644
index 00000000..65aa5e3c
--- /dev/null
+++ b/src/dsl/fusion/hook/Pool.hpp
@@ -0,0 +1,50 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2024 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef NUCLEAR_DSL_FUSION_HOOK_POOL_HPP
+#define NUCLEAR_DSL_FUSION_HOOK_POOL_HPP
+
+#include "../../../util/ThreadPoolDescriptor.hpp"
+
+namespace NUClear {
+namespace dsl {
+    namespace fusion {
+        namespace hook {
+
+            template <typename Word>
+            struct Pool {
+            private:
+                using PoolType = std::shared_ptr<const util::ThreadPoolDescriptor>;
+
+            public:
+                template <typename DSL, typename... Args>
+                static auto call(Args&&... args) -> decltype(Word::template pool<DSL>(std::forward<Args>(args)...),
+                                                             std::declval<PoolType>()) {
+                    return Word::template pool<DSL>(std::forward<Args>(args)...);
+                }
+            };
+
+        }  // namespace hook
+    }  // namespace fusion
+}  // namespace dsl
+}  // namespace NUClear
+
+#endif  // NUCLEAR_DSL_FUSION_HOOK_POOL_HPP
diff --git a/src/dsl/fusion/hook/PostRun.hpp b/src/dsl/fusion/hook/PostRun.hpp
new file mode 100644
index 00000000..9e40c863
--- /dev/null
+++ b/src/dsl/fusion/hook/PostRun.hpp
@@ -0,0 +1,45 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2024 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef NUCLEAR_DSL_FUSION_HOOK_POST_RUN_HPP
+#define NUCLEAR_DSL_FUSION_HOOK_POST_RUN_HPP
+
+namespace NUClear {
+namespace dsl {
+    namespace fusion {
+        namespace hook {
+
+            template <typename Word>
+            struct PostRun {
+            public:
+                template <typename DSL, typename... Args>
+                static auto call(Args&&... args)
+                    -> decltype(Word::template post_run<DSL>(std::forward<Args>(args)...)) {
+                    return Word::template post_run<DSL>(std::forward<Args>(args)...);
+                }
+            };
+
+        }  // namespace hook
+    }  // namespace fusion
+}  // namespace dsl
+}  // namespace NUClear
+
+#endif  // NUCLEAR_DSL_FUSION_HOOK_POST_RUN_HPP
diff --git a/src/dsl/fusion/hook/PreRun.hpp b/src/dsl/fusion/hook/PreRun.hpp
new file mode 100644
index 00000000..8934ccaa
--- /dev/null
+++ b/src/dsl/fusion/hook/PreRun.hpp
@@ -0,0 +1,44 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2024 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef NUCLEAR_DSL_FUSION_HOOK_PRE_RUN_HPP
+#define NUCLEAR_DSL_FUSION_HOOK_PRE_RUN_HPP
+
+namespace NUClear {
+namespace dsl {
+    namespace fusion {
+        namespace hook {
+
+            template <typename Word>
+            struct PreRun {
+            public:
+                template <typename DSL, typename... Args>
+                static auto call(Args&&... args) -> decltype(Word::template pre_run<DSL>(std::forward<Args>(args)...)) {
+                    return Word::template pre_run<DSL>(std::forward<Args>(args)...);
+                }
+            };
+
+        }  // namespace hook
+    }  // namespace fusion
+}  // namespace dsl
+}  // namespace NUClear
+
+#endif  // NUCLEAR_DSL_FUSION_HOOK_PRE_RUN_HPP
diff --git a/src/dsl/fusion/hook/Precondition.hpp b/src/dsl/fusion/hook/Precondition.hpp
new file mode 100644
index 00000000..a0c58850
--- /dev/null
+++ b/src/dsl/fusion/hook/Precondition.hpp
@@ -0,0 +1,50 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2024 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef NUCLEAR_DSL_FUSION_HOOK_PRECONDITION_HPP
+#define NUCLEAR_DSL_FUSION_HOOK_PRECONDITION_HPP
+
+namespace NUClear {
+namespace dsl {
+    namespace fusion {
+        namespace hook {
+
+            template <typename Word>
+            struct Precondition {
+            public:
+                template <typename DSL, typename... Args>
+                static auto call(Args&&... args)
+                    -> decltype(Word::template precondition<DSL>(std::forward<Args>(args)...)) {
+                    return Word::template precondition<DSL>(std::forward<Args>(args)...);
+                }
+
+                template <typename DSL>
+                static bool merge(const bool& lhs, const bool& rhs) {
+                    return lhs && rhs;
+                }
+            };
+
+        }  // namespace hook
+    }  // namespace fusion
+}  // namespace dsl
+}  // namespace NUClear
+
+#endif  // NUCLEAR_DSL_FUSION_HOOK_PRECONDITION_HPP
diff --git a/src/dsl/fusion/hook/Priority.hpp b/src/dsl/fusion/hook/Priority.hpp
new file mode 100644
index 00000000..9c0cb682
--- /dev/null
+++ b/src/dsl/fusion/hook/Priority.hpp
@@ -0,0 +1,50 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2024 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef NUCLEAR_DSL_FUSION_HOOK_PRIORITY_HPP
+#define NUCLEAR_DSL_FUSION_HOOK_PRIORITY_HPP
+
+namespace NUClear {
+namespace dsl {
+    namespace fusion {
+        namespace hook {
+
+            template <typename Word>
+            struct Priority {
+            public:
+                template <typename DSL, typename... Args>
+                static auto call(Args&&... args)
+                    -> decltype(Word::template priority<DSL>(std::forward<Args>(args)...)) {
+                    return Word::template priority<DSL>(std::forward<Args>(args)...);
+                }
+
+                template <typename DSL>
+                static int merge(const int& lhs, const int& rhs) {
+                    return std::max(lhs, rhs);
+                }
+            };
+
+        }  // namespace hook
+    }  // namespace fusion
+}  // namespace dsl
+}  // namespace NUClear
+
+#endif  // NUCLEAR_DSL_FUSION_HOOK_PRIORITY_HPP
diff --git a/src/dsl/fusion/has_bind.hpp b/src/dsl/fusion/hook/RunInline.hpp
similarity index 50%
rename from src/dsl/fusion/has_bind.hpp
rename to src/dsl/fusion/hook/RunInline.hpp
index 7991f5da..a6088042 100644
--- a/src/dsl/fusion/has_bind.hpp
+++ b/src/dsl/fusion/hook/RunInline.hpp
@@ -1,7 +1,7 @@
 /*
  * MIT License
  *
- * Copyright (c) 2014 NUClear Contributors
+ * Copyright (c) 2024 NUClear Contributors
  *
  * This file is part of the NUClear codebase.
  * See https://github.com/Fastcode/NUClear for further info.
@@ -19,43 +19,39 @@
  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-
-#ifndef NUCLEAR_DSL_FUSION_HAS_BIND_HPP
-#define NUCLEAR_DSL_FUSION_HAS_BIND_HPP
-
-#include "../../threading/ReactionHandle.hpp"
-#include "NoOp.hpp"
+#ifndef NUCLEAR_DSL_FUSION_HOOK_RUN_INLINE_HPP
+#define NUCLEAR_DSL_FUSION_HOOK_RUN_INLINE_HPP
 
 namespace NUClear {
 namespace dsl {
     namespace fusion {
-
-        /**
-         * SFINAE struct to test if the passed class has a bind function that conforms to the NUClear DSL.
-         *
-         * @tparam T the class to check
-         */
-        template <typename T>
-        struct has_bind {
-        private:
-            using yes = std::true_type;
-            using no  = std::false_type;
-
-            template <typename R, typename... A>
-            static yes test_func(R (*)(const std::shared_ptr<threading::Reaction>&, A...));
-            static no test_func(...);
-
-            template <typename U>
-            static auto test(int) -> decltype(test_func(U::template bind<ParsedNoOp>));
-            template <typename>
-            static no test(...);
-
-        public:
-            static constexpr bool value = std::is_same<decltype(test<T>(0)), yes>::value;
-        };
-
+        namespace hook {
+
+            template <typename Word>
+            struct RunInline {
+            public:
+                template <typename DSL, typename... Args>
+                static auto call(Args&&... args)
+                    -> decltype(Word::template run_inline<DSL>(std::forward<Args>(args)...)) {
+                    return Word::template run_inline<DSL>(std::forward<Args>(args)...);
+                }
+
+                template <typename DSL>
+                static util::Inline merge(const util::Inline& lhs, const util::Inline& rhs) {
+                    // Must agree or make a choice
+                    if ((lhs == util::Inline::ALWAYS && rhs == util::Inline::NEVER)
+                        || (lhs == util::Inline::NEVER && rhs == util::Inline::ALWAYS)) {
+                        throw std::logic_error("Cannot both always and never inline a reaction");
+                    }
+
+                    // Otherwise return the one that made lhs choice
+                    return lhs == util::Inline::NEUTRAL ? rhs : lhs;
+                }
+            };
+
+        }  // namespace hook
     }  // namespace fusion
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_FUSION_HASBIND_HPP
+#endif  // NUCLEAR_DSL_FUSION_HOOK_RUN_INLINE_HPP
diff --git a/src/dsl/fusion/hook/Scope.hpp b/src/dsl/fusion/hook/Scope.hpp
new file mode 100644
index 00000000..1da053f4
--- /dev/null
+++ b/src/dsl/fusion/hook/Scope.hpp
@@ -0,0 +1,54 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2024 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef NUCLEAR_DSL_FUSION_HOOK_SCOPE_HPP
+#define NUCLEAR_DSL_FUSION_HOOK_SCOPE_HPP
+
+#include <tuple>
+
+#include "../../../util/tuplify.hpp"
+
+namespace NUClear {
+namespace dsl {
+    namespace fusion {
+        namespace hook {
+
+            template <typename Word>
+            struct Scope {
+            public:
+                template <typename DSL, typename... Args>
+                static auto call(Args&&... args)
+                    -> decltype(util::tuplify(Word::template scope<DSL>(std::forward<Args>(args)...))) {
+                    return util::tuplify(Word::template scope<DSL>(std::forward<Args>(args)...));
+                }
+
+                template <typename DSL, typename LHS, typename RHS>
+                static auto merge(LHS&& lhs, RHS&& rhs) -> decltype(std::tuple_cat(lhs, rhs)) {
+                    return std::tuple_cat(lhs, rhs);
+                }
+            };
+
+        }  // namespace hook
+    }  // namespace fusion
+}  // namespace dsl
+}  // namespace NUClear
+
+#endif  // NUCLEAR_DSL_FUSION_HOOK_SCOPE_HPP
diff --git a/src/dsl/validation/Validation.hpp b/src/dsl/validation/Validation.hpp
index 3fbc3040..31dc16bf 100644
--- a/src/dsl/validation/Validation.hpp
+++ b/src/dsl/validation/Validation.hpp
@@ -41,9 +41,9 @@ namespace dsl {
         template <typename... Words>
         struct ValidateDSL {
 
-            // Check that at least one word element has a bind component
-            static_assert(Any<fusion::has_bind<Words>..., fusion::has_bind<operation::DSLProxy<Words>>...>::value,
-                          "The provided DSL sentence does not have any components that bind a function");
+            // // Check that at least one word element has a bind component
+            // static_assert(Any<fusion::has_bind<Words>..., fusion::has_bind<operation::DSLProxy<Words>>...>::value,
+            //               "The provided DSL sentence does not have any components that bind a function");
         };
 
         // TODO(Trent) Test that the function signature matches the arguments that will be obtained by get
diff --git a/src/dsl/word/Always.hpp b/src/dsl/word/Always.hpp
index 24506c33..9292f739 100644
--- a/src/dsl/word/Always.hpp
+++ b/src/dsl/word/Always.hpp
@@ -110,7 +110,7 @@ namespace dsl {
             }
 
             template <typename DSL>
-            static void postcondition(threading::ReactionTask& task) {
+            static void post_run(threading::ReactionTask& task) {
                 // Get a task for the always reaction and submit it to the scheduler
                 PowerPlant::powerplant->submit(task.parent->get_task());
             }
diff --git a/src/dsl/word/IO.hpp b/src/dsl/word/IO.hpp
index 9b6e2648..6b7f3cb0 100644
--- a/src/dsl/word/IO.hpp
+++ b/src/dsl/word/IO.hpp
@@ -154,7 +154,7 @@ namespace dsl {
             }
 
             template <typename DSL>
-            static void postcondition(threading::ReactionTask& task) {
+            static void post_run(threading::ReactionTask& task) {
                 task.parent->reactor.emit<emit::Inline>(std::make_unique<IOFinished>(task.parent->id));
             }
         };
diff --git a/src/dsl/word/Idle.hpp b/src/dsl/word/Idle.hpp
index 7b3763f3..6e36f4cb 100644
--- a/src/dsl/word/Idle.hpp
+++ b/src/dsl/word/Idle.hpp
@@ -28,7 +28,6 @@
 #include <typeindex>
 
 #include "../../threading/ReactionTask.hpp"
-#include "../fusion/NoOp.hpp"
 #include "MainThread.hpp"
 #include "Pool.hpp"
 
diff --git a/src/dsl/word/Once.hpp b/src/dsl/word/Once.hpp
index d0bb339b..7699971f 100644
--- a/src/dsl/word/Once.hpp
+++ b/src/dsl/word/Once.hpp
@@ -35,13 +35,13 @@ namespace dsl {
          *
          * @code on<Once>() @endcode
          * Any reactions listed with this DSL word will run only once.
-         * This is the only time these reactions will run as the postcondition Unbinds the current reaction.
+         * This is the only time these reactions will run as the post_run Unbinds the current reaction.
          */
         struct Once : Single {
 
             // Post condition to unbind this reaction.
             template <typename DSL>
-            static void postcondition(threading::ReactionTask& task) {
+            static void post_run(threading::ReactionTask& task) {
                 // Unbind:
                 task.parent->unbind();
             }
diff --git a/src/util/CallbackGenerator.hpp b/src/util/CallbackGenerator.hpp
index 2c2b039a..c796fc4b 100644
--- a/src/util/CallbackGenerator.hpp
+++ b/src/util/CallbackGenerator.hpp
@@ -132,8 +132,16 @@ namespace util {
 
                 // We have to catch any exceptions
                 try {
+                    // Create the scope object that wraps the execution of the callback
+                    auto scope = DSL::scope(task);
+
+                    DSL::pre_run(task);
+
                     // We call with only the relevant arguments to the passed function
                     util::apply_relevant(c, std::move(data));
+
+                    // Run our postconditions
+                    DSL::post_run(task);
                 }
                 catch (...) {
                     // Catch our exception if it happens
@@ -142,9 +150,6 @@ namespace util {
                     }
                 }
 
-                // Run our postconditions
-                DSL::postcondition(task);
-
                 if (task.statistics != nullptr) {
                     task.statistics->finished = message::ReactionStatistics::Event::now();
                     PowerPlant::powerplant->emit(std::make_unique<ReactionEvent>(Event::FINISHED, task.statistics));