From 56a91ba983a625f9be9abf19f1b610010c1c9d7b Mon Sep 17 00:00:00 2001
From: Antony Peacock <ant.peacock@gmail.com>
Date: Wed, 12 Nov 2025 18:36:37 +0000
Subject: [PATCH] Rename func ref conformance namespace

---
 .../morpheus/core/functional/function_ref.hpp | 19 +++++++++++--------
 .../tests/functional/function_ref.tests.cpp   |  6 +++---
 2 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/libraries/core/lib/morpheus/core/functional/function_ref.hpp b/libraries/core/lib/morpheus/core/functional/function_ref.hpp
index 287a1495..cc335df6 100644
--- a/libraries/core/lib/morpheus/core/functional/function_ref.hpp
+++ b/libraries/core/lib/morpheus/core/functional/function_ref.hpp
@@ -1,9 +1,10 @@
 #pragma once
 
-#include <concepts>
-#include <functional>
 #include <morpheus/core/conformance/version.hpp>
 #include <morpheus/core/meta/invocable_traits.hpp>
+
+#include <concepts>
+#include <functional>
 #include <type_traits>
 #include <utility>
 
@@ -11,12 +12,12 @@
 
 namespace morpheus::conf
 {
-namespace func_ref = std;
+namespace fr = std;
 }
 
 #else
 
-namespace morpheus::conf::func_ref
+namespace morpheus::conf::fr
 {
 
 /// \struct nontype_t
@@ -98,7 +99,8 @@ class function_ref<Return(Args...)>
     template <class F>
     function_ref(F* f) noexcept
     requires std::is_function_v<F> and isInvokableWith<F>
-        : mInvoke([](Storage storage, Args... args) noexcept(isNoexcept) { return invoke(function_ref::get<F>(storage), std::forward<Args>(args)...); })
+        : mInvoke([](Storage storage, Args... args) noexcept(isNoexcept) -> Return
+                  { return invoke(function_ref::get<F>(storage), std::forward<Args>(args)...); })
         , mStorage(f)
     {}
 
@@ -180,7 +182,7 @@ class function_ref<Return(Args...)>
         template <class F>
         requires std::is_function_v<F>
         constexpr explicit Storage(F* f) noexcept
-            : fp(f)
+            : fp(reinterpret_cast<void (*)()>(f))
         {}
     };
 
@@ -193,7 +195,7 @@ class function_ref<Return(Args...)>
         else if constexpr (std::is_object_v<T>)
             return static_cast<T*>(storage.p);
         else
-            return static_cast<T*>(storage.fp);
+            return reinterpret_cast<T*>(storage.fp);
     }
 
     using InternalInvocableType = Return(Storage, Args...);
@@ -226,5 +228,6 @@ function_ref(nontype_t<f>) -> function_ref<std::remove_pointer_t<decltype(f)>>;
     function_ref(F) -> function_ref<see below>;
 */
 
-} // namespace morpheus::conf::func_ref
+} // namespace morpheus::conf::fr
+
 #endif
diff --git a/libraries/core/tests/functional/function_ref.tests.cpp b/libraries/core/tests/functional/function_ref.tests.cpp
index 9e356bf1..2204b519 100644
--- a/libraries/core/tests/functional/function_ref.tests.cpp
+++ b/libraries/core/tests/functional/function_ref.tests.cpp
@@ -9,7 +9,7 @@ namespace morpheus::functional
 
 TEST_CASE("Propagate constness and noexceptness to function_ref", "[morpheus.functional.function_ref]")
 {
-    using ConcreteFunctionRef = conf::func_ref::function_ref<void()>;
+    using ConcreteFunctionRef = conf::fr::function_ref<void()>;
     STATIC_REQUIRE(std::is_nothrow_copy_constructible_v<ConcreteFunctionRef>);
     STATIC_REQUIRE(std::is_nothrow_copy_assignable_v<ConcreteFunctionRef>);
     STATIC_REQUIRE(std::is_nothrow_move_constructible_v<ConcreteFunctionRef>);
@@ -27,7 +27,7 @@ TEST_CASE("Verify construction of function_ref", "[morpheus.functional.function_
     {
         WHEN("Constructing a function reference to the function")
         {
-            conf::func_ref::function_ref<void()> functionView = testFunction;
+            conf::fr::function_ref<void()> functionView = testFunction;
             THEN("Expect the function to be invocable by the function ref")
             {
                 functionView();
@@ -45,7 +45,7 @@ TEST_CASE("Verify construction of function_ref", "[morpheus.functional.function_
         WHEN("Constructing a function reference to the function")
         {
             TestForInvocable instance;
-            conf::func_ref::function_ref<void(int, int)> functionView = {conf::func_ref::nontype<&TestForInvocable::function>, instance};
+            conf::fr::function_ref<void(int, int)> functionView = {conf::fr::nontype<&TestForInvocable::function>, instance};
             THEN("Expect the function to be invocable by the function ref")
             {
                 functionView(0, 1);