@micro-os-plus/micro-test-plus 3.3.1 → 4.0.0

package/include/micro-os-plus/micro-test-plus/type-traits.h

@@ -55,6 +55,8 @@
 // ----------------------------------------------------------------------------
 
 #include "math.h"
+#include <string_view>
+#include <type_traits>
 
 // ----------------------------------------------------------------------------
 
@@ -66,6 +68,8 @@
 #endif
 #endif
 
+// ============================================================================
+
 namespace micro_os_plus::micro_test_plus
 {
   // --------------------------------------------------------------------------
@@ -83,7 +87,7 @@ namespace micro_os_plus::micro_test_plus
    * This includes templates for function traits, type lists, identity, value
    * wrappers, and compile-time checks for container types, floating point
    * types, and type convertibility. It also provides generic integral and
-   * floating point constant wrappers, as well as mechanisms for SFINAE and
+   * floating point constant wrappers, as well as C++20 concepts and
    * requirements checking.
    *
    * These utilities facilitate advanced template programming, type deduction,
@@ -123,7 +127,10 @@ namespace micro_os_plus::micro_test_plus
      * @brief Struct template for compile-time type identity.
      *
      * @tparam T The type to be preserved.
-     * @tparam Extra Additional template parameters, ignored.
+     * @tparam Extra Additional template parameters, ignored. The variadic
+     *   `Extra` parameter pack absorbs additional type arguments that may
+     *   arise during template argument deduction in some metaprogramming
+     *   contexts, preventing substitution failures.
      *
      * @details
      * The `identity` struct template provides a mechanism for preserving a
@@ -132,8 +139,8 @@ namespace micro_os_plus::micro_test_plus
      * within the µTest++ framework.
      *
      * This utility is particularly useful in scenarios where type deduction or
-     * SFINAE is required, as it allows the type to be carried through template
-     * specialisations without modification.
+     * concept constraints are required, as it allows the type to be carried
+     * through template specialisations without modification.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
@@ -314,369 +321,240 @@ namespace micro_os_plus::micro_test_plus
       using args = list<Args_T...>;
     };
 
-    /**
-     * @brief Utility function template to simulate std::declval for type
-     * deduction.
-     *
-     * @tparam T The type for which an rvalue reference is required.
-     *
-     * @par Parameters
-     *	 None.
-     * @return An rvalue reference to type `T`.
-     *
-     * @details
-     * The `declval` function template provides a mechanism for obtaining an
-     * rvalue reference to a type `T` without requiring an actual object. This
-     * is primarily used in unevaluated contexts, such as within `decltype`, to
-     * deduce types during template metaprogramming in the µTest++ framework.
-     */
-    template <class T>
-    T&&
-    declval (void);
-    template <class... Ts, class Expr_T>
-    constexpr auto
-    is_valid (Expr_T expr) -> decltype (expr (declval<Ts...> ()), bool ())
-    {
-      return true;
-    }
+    // ------------------------------------------------------------------------
 
     /**
-     * @brief Fallback function template for is_valid, returns false if the
-     * expression is not valid.
+     * @brief Empty base struct for all operator types.
      *
-     * @tparam Ts The argument types to be tested.
+     * @details
+     * The `op` struct serves as a common base for all operator and value
+     * wrapper types used in the µTest++ framework's type traits and
+     * metaprogramming utilities. It provides a unified type hierarchy,
+     * enabling compile-time detection and generic handling of operator-like
+     * types within the framework.
      *
-     * @return `false` indicating the expression is not valid for the given
-     * argument types.
+     * This struct is intended for internal use as a base for integral
+     * constants, floating point constants, and other value wrappers,
+     * supporting advanced template metaprogramming and type introspection.
      *
-     * @details
-     * This overload is selected when the primary `is_valid` template cannot be
-     * instantiated, providing a `false` result for invalid expressions.
+     * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
-    template <class... Ts>
-    constexpr auto
-    is_valid (...) -> bool
+    struct op
     {
-      return false;
-    }
+    };
+
+    // ------------------------------------------------------------------------
+    // Concepts.
 
     /**
-     * @brief Variable template to determine if a type models a container.
-     *
-     * @tparam T The type to be checked for container-like behaviour.
+     * @brief C++20 concept satisfied when `T` provides both `begin()` and
+     * `end()` member functions.
      *
-     * @retval true if `T` has both `begin()` and `end()` member functions.
-     * @retval false otherwise.
+     * @tparam T The type to be checked.
      *
      * @details
-     * The `is_container_v` variable template evaluates to `true` if the given
-     * type `T` provides both `begin()` and `end()` member functions,
-     * indicating that it models a standard container concept. This trait is
-     * determined at compile time using SFINAE and is_valid, and is used
-     * throughout the µTest++ framework to enable generic handling of container
-     * types in template metaprogramming.
+     * The `container_like` concept is satisfied when `T` exposes both a
+     * `begin()` and an `end()` member function, as required by standard
+     * range-based iteration. It is used to detect container types for
+     * specialised comparison and reporting within the framework.
      */
     template <class T>
-    static constexpr auto is_container_v = is_valid<T> (
-        [] (auto t) -> decltype (t.begin (), t.end (), void ()) {});
+    concept container_like = requires (const T& t) {
+      t.begin ();
+      t.end ();
+    };
 
     /**
-     * @brief Variable template to determine if a type provides a static `npos`
-     * member.
-     *
-     * @tparam T The type to be checked for the presence of a static `npos`
-     * member.
+     * @brief C++20 concept satisfied when `T` provides a `npos` member.
      *
-     * @retval true if `T` has a static member named `npos`.
-     * @retval false otherwise.
+     * @tparam T The type to be checked.
      *
      * @details
-     * The `has_npos_v` variable template evaluates to `true` if the given type
-     * `T` defines a static member named `npos`. This trait is determined at
-     * compile time using SFINAE and the `is_valid` utility, and is used
-     * throughout the µTest++ framework to enable generic handling of types
-     * that follow the standard string or container conventions.
+     * The `has_npos` concept is satisfied when `T` exposes a static `npos`
+     * member, as provided by `std::string_view` and similar types. It is
+     * used to detect string-like types for specialised comparison and
+     * reporting within the framework.
      */
     template <class T>
-    static constexpr auto has_npos_v
-        = is_valid<T> ([] (auto t) -> decltype (void (t.npos)) {});
+    concept has_npos = requires { T::npos; };
 
     /**
-     * @brief Variable template to determine if a type provides a `value`
-     * member.
+     * @brief C++20 concept satisfied when `T` provides a `value` member.
      *
-     * @tparam T The type to be checked for the presence of a `value` member.
-     *
-     * @retval true if `T` has a member named `value`.
-     * @retval false otherwise.
+     * @tparam T The type to be checked.
      *
      * @details
-     * The `has_value_v` variable template evaluates to `true` if the given
-     * type `T` defines a member named `value`. This trait is determined at
-     * compile time using SFINAE and the `is_valid` utility, and is used
-     * throughout the µTest++ framework to enable generic handling of types
-     * that encapsulate a value, such as wrappers or constant types.
+     * The `has_value` concept is satisfied when an instance of `T` exposes
+     * a `value` member. It is used to detect framework value-wrapper types
+     * such as `integral_constant`, `floating_point_constant`, and `value<T>`,
+     * enabling specialised comparison and reporting.
      */
     template <class T>
-    static constexpr auto has_value_v
-        = is_valid<T> ([] (auto t) -> decltype (void (t.value)) {});
+    concept has_value = requires (const T& t) { t.value; };
 
     /**
-     * @brief Variable template to determine if a type provides an `epsilon`
-     * member.
-     *
-     * @tparam T The type to be checked for the presence of an `epsilon`
-     * member.
+     * @brief C++20 concept satisfied when `T` provides an `epsilon` member.
      *
-     * @retval true if `T` has a member named `epsilon`.
-     * @retval false otherwise.
+     * @tparam T The type to be checked.
      *
      * @details
-     * The `has_epsilon_v` variable template evaluates to `true` if the given
-     * type `T` defines a member named `epsilon`. This trait is determined at
-     * compile time using SFINAE and the `is_valid` utility, and is used
-     * throughout the µTest++ framework to enable generic handling of types
-     * that represent floating-point values or require precision control.
+     * The `has_epsilon` concept is satisfied when an instance of `T` exposes
+     * an `epsilon` member. It is used to detect floating point value-wrapper
+     * types such as `floating_point_constant` and the floating point
+     * specialisation of `value<T>`, enabling precision-aware comparisons.
      */
     template <class T>
-    static constexpr auto has_epsilon_v
-        = is_valid<T> ([] (auto t) -> decltype (void (t.epsilon)) {});
+    concept has_epsilon = requires (const T& t) { t.epsilon; };
 
     /**
-     * @brief Variable template to determine if a type is a floating point
+     * @brief C++20 concept satisfied when `T` is a standard floating point
      * type.
      *
-     * @tparam T The type to be checked for floating point classification.
-     *
-     * @retval true if `T` is a floating point type.
-     * @retval false otherwise.
+     * @tparam T The type to be checked.
      *
      * @details
-     * The `is_floating_point_v` variable template evaluates to `true` if the
-     * given type `T` is a floating point type (`float`, `double`, or `long
-     * double`). For all other types, it evaluates to `false`. This trait is
-     * used throughout the µTest++ framework to enable type-safe handling and
-     * specialisation for floating point types in template metaprogramming.
-     *
-     * Specialisations are provided for `float`, `double`, and `long double`,
-     * each evaluating to `true`.
+     * The `is_floating_point` concept is satisfied when `T` is one of the
+     * standard floating point types (`float`, `double`, or `long double`).
+     * It is the primary definition; `is_floating_point_v` is derived from
+     * it for use in `if constexpr` and non-concept contexts.
      */
     template <class T>
-    inline constexpr auto is_floating_point_v = false;
-
-    /**
-     * @brief Variable template specialisation indicating that `float` is a
-     * floating point type.
-     *
-     * @details
-     * This specialisation of the `is_floating_point_v` variable template
-     * evaluates to `true` for the `float` type, confirming that it is
-     * recognised as a floating point type within the µTest++ framework. This
-     * enables type-safe handling and specialisation for floating point types
-     * in template metaprogramming.
-     *
-     * @see is_floating_point_v
-     */
-    template <>
-    inline constexpr auto is_floating_point_v<float> = true;
+    concept is_floating_point = std::is_floating_point_v<T>;
 
     /**
-     * @brief Variable template specialisation indicating that `double` is a
-     * floating point type.
+     * @brief C++20 concept satisfied when a type derives from `op`.
      *
-     * @details
-     * This specialisation of the `is_floating_point_v` variable template
-     * evaluates to `true` for the `double` type, confirming that it is
-     * recognised as a floating point type within the µTest++ framework. This
-     * enables type-safe handling and specialisation for floating point types
-     * in template metaprogramming.
-     *
-     * @see is_floating_point_v
-     */
-    template <>
-    inline constexpr auto is_floating_point_v<double> = true;
-
-    /**
-     * @brief Variable template specialisation indicating that `long double` is
-     * a floating point type.
+     * @tparam T The type to be checked.
      *
      * @details
-     * This specialisation of the `is_floating_point_v` variable template
-     * evaluates to `true` for the `long double` type, confirming that it is
-     * recognised as a floating point type within the µTest++ framework. This
-     * enables type-safe handling and specialisation for floating point types
-     * in template metaprogramming.
-     *
-     * @see is_floating_point_v
+     * The `is_op` concept is satisfied when `T` is derived from the
+     * `type_traits::op` base struct. It is the primary definition used
+     * throughout the framework; `is_op_v` is derived from it for use in
+     * `if constexpr` and boolean contexts.
      */
-    template <>
-    inline constexpr auto is_floating_point_v<long double> = true;
+    template <class T>
+    concept is_op = std::is_base_of_v<type_traits::op, T>;
 
-#if defined(__clang__) or defined(_MSC_VER)
     /**
-     * @brief Variable template to determine if one type is convertible to
-     * another.
-     *
-     * @tparam From The source type to be checked for convertibility.
-     * @tparam To The target type to which conversion is tested.
+     * @brief C++20 concept satisfied when at least one of two types derives
+     * from `op`.
      *
-     * @retval true if `From` is convertible to `To`.
-     * @retval false otherwise.
+     * @tparam Lhs_T The type of the left-hand operand.
+     * @tparam Rhs_T The type of the right-hand operand.
      *
      * @details
-     * The `is_convertible_v` variable template evaluates to `true` if the type
-     * `From` is implicitly convertible to the type `To`, and `false`
-     * otherwise. This trait is determined at compile time and is used
-     * throughout the µTest++ framework to enable type-safe conversions and
-     * requirements checking in template metaprogramming.
-     *
-     * On supported compilers, this trait leverages compiler intrinsics for
-     * optimal performance and accuracy.
+     * The `any_op` concept is satisfied when `Lhs_T` or `Rhs_T` (or both)
+     * are derived from the `type_traits::op` base struct. It is used to
+     * constrain binary operator overloads in the `operators` namespace so
+     * that they are enabled only when at least one operand is a framework
+     * type, avoiding unintended conflicts with user-defined operators.
      */
-    template <class From, class To>
-    static constexpr auto is_convertible_v = __is_convertible_to (From, To);
-#else
-    /**
-     * @brief Function template to determine if one type is convertible to
-     * another.
-     *
-     * @tparam From The source type to be checked for convertibility.
-     * @tparam To The target type to which conversion is tested.
-     *
-     * @param n Dummy parameter used for overload resolution.
-     * @retval true if `From` is convertible to `To`.
-     *
-     * @details
-     * The `is_convertible` function template checks, at compile time, whether
-     * a value of type `From` can be implicitly converted to type `To`. This is
-     * achieved using SFINAE and is primarily used as an implementation detail
-     * for the `is_convertible_v` variable template within the µTest++
-     * framework.
-     *
-     * If the conversion is valid, this overload is selected and returns
-     * `true`.
-     */
-    template <class From, class To>
-    constexpr auto
-    is_convertible (int n) -> decltype (bool (To (declval<From> ())))
-    {
-      (void)n; // Prevent the unused parameter warning.
-      return true;
-    }
+    template <class Lhs_T, class Rhs_T>
+    concept any_op = is_op<Lhs_T> or is_op<Rhs_T>;
 
     /**
-     * @brief Fallback function template for is_convertible, returns false if
-     * the conversion is not valid.
+     * @brief C++20 concept satisfied when a type can be used as a test
+     * expression in `expect()` or `assume()`.
      *
-     * @tparam ...Unused Unused template parameters.
-     *
-     * @retval false indicating the conversion is not valid.
+     * @tparam T The type to be checked.
      *
      * @details
-     * This overload is selected when the primary `is_convertible` template
-     * cannot be instantiated, providing a `false` result for invalid
-     * conversions.
+     * The `checkable` concept is satisfied when `T` is either a
+     * framework operator type (derived from `op`) or is implicitly
+     * convertible to `bool`. It is used to constrain the `expect()` and
+     * `assume()` function templates, ensuring that only sensible
+     * expression types are accepted.
      */
-    template <class...>
-    constexpr auto
-    is_convertible (...)
-    {
-      return false;
-    }
+    template <class T>
+    concept checkable = is_op<T> or std::convertible_to<T, bool>;
 
     /**
-     * @brief Variable template to determine if one type is convertible to
-     * another.
-     *
-     * @tparam From The source type to be checked for convertibility.
-     * @tparam To The target type to which conversion is tested.
+     * @brief C++20 concept satisfied when a type can be appended to the
+     * deferred reporter's output via `operator<<`.
      *
-     * @retval true if `From` is convertible to `To`.
-     * @retval false otherwise.
+     * @tparam T The type to be checked.
      *
      * @details
-     * The `is_convertible_v` variable template evaluates to `true` if the type
-     * `From` is implicitly convertible to the type `To`, and `false`
-     * otherwise. This trait is determined at compile time and is used
-     * throughout the µTest++ framework to enable type-safe conversions and
-     * requirements checking in template metaprogramming.
+     * The `printable` concept is satisfied when `T` is an arithmetic
+     * type or is implicitly convertible to `std::string_view`. It
+     * constrains the `operator<<` overload of `deferred_reporter_base`,
+     * ensuring that only types that can be meaningfully appended to the
+     * output message are accepted.
      */
-    template <class From, class To>
-    constexpr auto is_convertible_v = is_convertible<From, To> (0);
-#endif
+    template <class T>
+    concept printable = std::is_arithmetic_v<T>
+                        or std::is_convertible_v<T, std::string_view>;
+
+    // ------------------------------------------------------------------------
 
     /**
-     * @brief Struct template for SFINAE requirements.
+     * @brief Base struct template providing common storage and accessors
+     * for runtime value-wrapper types.
+     *
+     * @tparam T The type of the stored value.
      *
      * @details
-     * The `requires_` struct template is a utility for SFINAE (Substitution
-     * Failure Is Not An Error) in template metaprogramming. It is typically
-     * used to enable or disable template specialisations and function
-     * templates based on compile-time boolean conditions.
+     * The `value_base_` struct template provides the `T value_{}` member,
+     * an explicit `operator T()` conversion, and a `get()` accessor,
+     * shared by `genuine_integral_value`, `value<T>`, and the floating
+     * point specialisation `value<T>`.
      *
-     * When the boolean template parameter is `true`, the specialisation
-     * provides a nested `type` alias, which can be used in conjunction with
-     * `typename` and `requires_t` to enforce requirements in template
-     * declarations.
+     * It inherits from `op` so that all derived types satisfy the `is_op`
+     * concept without each struct needing to inherit from `op` directly.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
-    template <bool Cond>
-    struct requires_
+    template <class T>
+    struct value_base_ : op
     {
-    };
+      /**
+       * @brief The type of the stored value.
+       */
+      using value_type = T;
 
-    /**
-     * @brief Specialisation of the requirements struct template for `true`.
-     *
-     * @details
-     * When the condition is `true`, this specialisation provides a nested
-     * `type` alias, typically used for SFINAE and requirements checking in
-     * template metaprogramming.
-     *
-     * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
-     */
-    template <>
-    struct requires_<true>
-    {
       /**
-       * @brief Alias type provided when the requirement is satisfied.
+       * @brief Constructs a `value_base_` with the given value.
+       *
+       * @param v The value to be stored.
        */
-      using type = int;
-    };
+      constexpr explicit value_base_ (const T& v) noexcept : value_{ v }
+      {
+      }
 
-    /**
-     * @brief Alias template for extracting the `type` member from `requires_`.
-     *
-     * @tparam Cond The boolean condition to be checked at compile time.
-     *
-     * @details
-     * The `requires_t` alias template simplifies the use of the `requires_`
-     * struct template by directly exposing the nested `type` member. It is
-     * commonly used to enforce compile-time requirements in template
-     * declarations.
-     */
-    template <bool Cond>
-    using requires_t = typename requires_<Cond>::type;
+      /**
+       * @brief Explicit conversion operator to the underlying value type.
+       *
+       * @return The stored value as type `T`.
+       *
+       * @details
+       * Allows explicit conversion to the encapsulated value.
+       */
+      [[nodiscard]] constexpr explicit
+      operator T () const noexcept
+      {
+        return value_;
+      }
 
-    /**
-     * @brief Empty base struct for all operator types.
-     *
-     * @details
-     * The `op` struct serves as a common base for all operator and value
-     * wrapper types used in the µTest++ framework's type traits and
-     * metaprogramming utilities. It provides a unified type hierarchy,
-     * enabling compile-time detection and generic handling of operator-like
-     * types within the framework.
-     *
-     * This struct is intended for internal use as a base for integral
-     * constants, floating point constants, and other value wrappers,
-     * supporting advanced template metaprogramming and type introspection.
-     *
-     * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
-     */
-    struct op
-    {
+      /**
+       * @brief Getter for the stored value.
+       *
+       * @par Parameters
+       *	 None.
+       * @return The stored value.
+       *
+       * @details
+       * Returns the stored value by value.
+       */
+      [[nodiscard]] constexpr T
+      get (void) const noexcept
+      {
+        return value_;
+      }
+
+      /**
+       * @brief The stored value.
+       */
+      T value_{};
     };
 
     /**
@@ -687,28 +565,30 @@ namespace micro_os_plus::micro_test_plus
      * @details
      * The `integral_constant` struct template provides a compile-time constant
      * value of an integral type, with additional utility features. It inherits
-     * from `op` to enable unified handling within the µTest++ framework's type
-     * traits and metaprogramming utilities.
+     * from `value_base_<decltype(N)>`, which supplies the `value_type` alias,
+     * the `value_` runtime member, the explicit conversion operator, and the
+     * `get()` accessor.
      *
-     * This struct template exposes the constant value via a static member, a
-     * getter method, and explicit conversion operators. It also provides a
+     * This struct retains the compile-time `value` constant and provides a
      * unary minus operator to obtain the negative value as a new
      * `integral_constant` instance.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <auto N>
-    struct integral_constant : op
+    struct integral_constant : value_base_<decltype (N)>
     {
       /**
-       * @brief The type of the constant value.
+       * @brief The compile-time constant value.
        */
-      using value_type = decltype (N);
+      static constexpr auto value = N;
 
       /**
-       * @brief The constant value.
+       * @brief Default constructor. Initialises the base with `N`.
        */
-      static constexpr auto value = N;
+      constexpr integral_constant () noexcept : value_base_<decltype (N)>{ N }
+      {
+      }
 
       /**
        * @brief Unary minus operator.
@@ -720,42 +600,10 @@ namespace micro_os_plus::micro_test_plus
        * of the current value.
        */
       [[nodiscard]] constexpr auto
-      operator- () const
+      operator- () const noexcept
       {
         return integral_constant<-N>{};
       }
-
-      /**
-       * @brief Explicit conversion operator to value_type.
-       *
-       * @par Parameters
-       *	 None.
-       * @return The constant value as type `value_type`.
-       *
-       * @details
-       * Allows explicit conversion to the underlying value type.
-       */
-      [[nodiscard]] constexpr explicit
-      operator value_type (void) const
-      {
-        return N;
-      }
-
-      /**
-       * @brief Getter for the constant value.
-       *
-       * @par Parameters
-       *	 None.
-       * @return The constant value.
-       *
-       * @details
-       * Returns the compile-time constant value.
-       */
-      [[nodiscard]] constexpr auto
-      get (void) const
-      {
-        return N;
-      }
     };
 
     /**
@@ -772,23 +620,28 @@ namespace micro_os_plus::micro_test_plus
      * @details
      * The `floating_point_constant` struct template provides a compile-time
      * constant value of a floating point type, supporting custom size and
-     * precision. It inherits from `op` to enable unified handling within the
-     * µTest++ framework's type traits and metaprogramming utilities.
-     *
-     * This struct template exposes the constant value via a static member, a
-     * getter method, and explicit conversion operators. It also provides a
-     * unary minus operator to obtain the negative value as a new
-     * `floating_point_constant` instance. The `epsilon` member defines the
-     * precision used for floating point comparisons, calculated based on the
-     * specified size.
+     * precision. It inherits from `op` directly rather than from
+     * `value_base_<T>`, which avoids introducing a user-provided constructor
+     * into the type and keeps it trivially default-constructible. This
+     * prevents the GCC ARM PSABI note about parameter-passing ABI changes
+     * that is emitted for non-trivially-constructible types under C++17.
+     *
+     * The `value_type` alias, explicit conversion operator, and `get()`
+     * accessor are provided directly by this struct. The compile-time
+     * `epsilon` and `value` static constants are retained, and a unary
+     * minus operator is provided to obtain the negative value as a new
+     * `floating_point_constant` instance.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class T, auto N, auto D, auto Size, auto P = 1>
     struct floating_point_constant : op
     {
+      static_assert (P == 1 || P == -1,
+                     "floating_point_constant: P must be +1 or -1");
+
       /**
-       * @brief The type of the constant value.
+       * @brief The type of the stored value.
        */
       using value_type = T;
 
@@ -801,7 +654,7 @@ namespace micro_os_plus::micro_test_plus
       static constexpr auto epsilon = T (1) / math::pow (T (10), Size - 1);
 
       /**
-       * @brief The constant value.
+       * @brief The compile-time constant value.
        *
        * @details
        * Computed as `P * (N + D / 10^Size)`.
@@ -810,47 +663,42 @@ namespace micro_os_plus::micro_test_plus
           = T (P) * (T (N) + (T (D) / math::pow (T (10), Size)));
 
       /**
-       * @brief Unary minus operator.
-       *
-       * @return A `floating_point_constant` with value `-value`.
+       * @brief Explicit conversion operator to the underlying value type.
        *
-       * @details
-       * Returns a new `floating_point_constant` instance representing the
-       * negative of the current value.
+       * @return The compile-time constant as type `T`.
        */
-      [[nodiscard]] constexpr auto
-      operator- () const
+      [[nodiscard]] constexpr explicit
+      operator T () const noexcept
       {
-        return floating_point_constant<T, N, D, Size, -1>{};
+        return value;
       }
 
       /**
-       * @brief Explicit conversion operator to value_type.
+       * @brief Getter for the compile-time constant value.
        *
-       * @return The constant value as type `value_type`.
-       *
-       * @details
-       * Allows explicit conversion to the underlying floating point value
-       * type.
+       * @par Parameters
+       *	 None.
+       * @return The compile-time constant as type `T`.
        */
-      [[nodiscard]] constexpr explicit
-      operator value_type () const
+      [[nodiscard]] constexpr T
+      get (void) const noexcept
       {
         return value;
       }
 
       /**
-       * @brief Getter for the constant value.
+       * @brief Unary minus operator.
        *
-       * @return The constant value.
+       * @return A `floating_point_constant` with negated sign parameter.
        *
        * @details
-       * Returns the compile-time floating point constant value.
+       * Returns a new `floating_point_constant` instance representing the
+       * negative of the current value by flipping the sign parameter `P`.
        */
       [[nodiscard]] constexpr auto
-      get () const
+      operator- () const noexcept
       {
-        return value;
+        return floating_point_constant<T, N, D, Size, -P>{};
       }
     };
 
@@ -861,161 +709,49 @@ namespace micro_os_plus::micro_test_plus
      *
      * @details
      * The `genuine_integral_value` struct template encapsulates a runtime
-     * integral value, providing a consistent interface for value access and
-     * conversion. It inherits from `op` to enable unified handling within the
-     * µTest++ framework's type traits and metaprogramming utilities.
-     *
-     * This struct template exposes the value via a member variable, a getter
-     * method, and an explicit conversion operator. It is intended for use
-     * cases where a value must be wrapped and treated generically within the
-     * framework, supporting advanced template metaprogramming and type
-     * introspection.
+     * integral value. The stored value, explicit conversion operator, and
+     * getter are provided by the `value_base_` base.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class T>
-    struct genuine_integral_value : op
+    struct genuine_integral_value : value_base_<T>
     {
-      /**
-       * @brief The type of the encapsulated value.
-       */
-      using value_type = T;
-
       /**
        * @brief Constructs a genuine_integral_value with the specified value.
        *
        * @param _value The integral value to be stored.
        */
-      constexpr genuine_integral_value (const T& _value) : value_{ _value }
-      {
-      }
-
-      /**
-       * @brief Explicit conversion operator to the underlying value type.
-       *
-       * @return The stored value as type `T`.
-       *
-       * @details
-       * Allows explicit conversion to the encapsulated value.
-       */
-      [[nodiscard]] constexpr explicit
-      operator T () const
+      constexpr genuine_integral_value (const T& _value) noexcept
+          : value_base_<T>{ _value }
       {
-        return value_;
       }
-
-      /**
-       * @brief Getter for the encapsulated value.
-       *
-       * @return The value of type `T`.
-       *
-       * @details
-       * Returns the stored integral value.
-       */
-      [[nodiscard]] constexpr decltype (auto)
-      get () const
-      {
-        return value_;
-      }
-
-      /**
-       * @brief The encapsulated integral value.
-       */
-      T value_{};
     };
 
-    /**
-     * @brief Variable template to determine if a type derives from `op`.
-     *
-     * @tparam T The type to be checked for derivation from `op`.
-     *
-     * @retval true if `T` is derived from `type_traits::op`.
-     * @retval false otherwise.
-     *
-     * @details
-     * The `is_op_v` variable template evaluates to `true` if the given type
-     * `T` is derived from the `type_traits::op` base struct, and `false`
-     * otherwise. This trait is determined at compile time using compiler
-     * intrinsics and is used throughout the µTest++ framework to enable
-     * generic handling and detection of operator-like or value wrapper types
-     * in template metaprogramming.
-     */
-    template <class T>
-    inline constexpr auto is_op_v = __is_base_of (type_traits::op, T);
-
     /**
      * @brief Struct template representing a generic value, accessible via a
      * getter.
      *
      * @tparam T The type of the value to be encapsulated.
-     * @tparam Opt An optional parameter for SFINAE or specialisation,
-     * defaults to `int`.
      *
      * @details
-     * The `value` struct template encapsulates a value of type `T`, providing
-     * a consistent interface for value access and conversion. It inherits from
-     * `type_traits::op` to enable unified handling within the µTest++
-     * framework's type traits and metaprogramming utilities.
-     *
-     * This struct template exposes the value via a member variable, a getter
-     * method, and an explicit conversion operator. It is intended for use
-     * cases where a value must be wrapped and treated generically within the
-     * framework, supporting advanced template metaprogramming and type
-     * introspection.
+     * The `value` struct template encapsulates a value of type `T`. The
+     * stored value, explicit conversion operator, and getter are provided
+     * by the `value_base_` base.
      *
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
-    template <class T, class Opt = int>
-    struct value : type_traits::op
+    template <class T>
+    struct value : value_base_<T>
     {
-      /**
-       * @brief The type of the encapsulated value.
-       */
-      using value_type = T;
-
       /**
        * @brief Constructs a value object with the specified value.
        *
        * @param _value The value to be stored.
        */
-      constexpr value (const T& _value) : value_{ _value }
+      constexpr value (const T& _value) noexcept : value_base_<T>{ _value }
       {
       }
-
-      /**
-       * @brief Explicit conversion operator to the underlying value type.
-       *
-       * @return The stored value as type `T`.
-       *
-       * @details
-       * Allows explicit conversion to the encapsulated value.
-       */
-      [[nodiscard]] constexpr explicit
-      operator T () const
-      {
-        return value_;
-      }
-
-      /**
-       * @brief Getter for the encapsulated value.
-       *
-       * @par Parameters
-       *	 None.
-       * @return The value of type `T`.
-       *
-       * @details
-       * Returns the stored value.
-       */
-      [[nodiscard]] constexpr decltype (auto)
-      get (void) const
-      {
-        return value_;
-      }
-
-      /**
-       * @brief The encapsulated value.
-       */
-      T value_{};
     };
 
     /**
@@ -1027,15 +763,12 @@ namespace micro_os_plus::micro_test_plus
      * @details
      * The `value` struct template specialisation for floating point types
      * encapsulates a value of type `T` and provides an associated `epsilon`
-     * for precision control during comparisons. It inherits from
-     * `type_traits::op` to enable unified handling within the µTest++
-     * framework's type traits and metaprogramming utilities.
+     * for precision control during comparisons. The stored value, explicit
+     * conversion operator, and getter are provided by the `value_base_` base.
      *
-     * This struct template exposes the value via a member variable, a getter
-     * method, and an explicit conversion operator. The `epsilon` member
-     * defines the precision used for floating point comparisons and can be set
-     * explicitly or computed as a default based on the number of decimal
-     * digits in the value.
+     * The `epsilon` member defines the precision used for floating point
+     * comparisons and can be set explicitly or computed as a default based
+     * on the number of decimal digits in the value.
      *
      * This specialisation is intended for use cases where floating point
      * values require controlled precision, supporting advanced template
@@ -1044,34 +777,30 @@ namespace micro_os_plus::micro_test_plus
      * @headerfile micro-test-plus.h <micro-os-plus/micro-test-plus.h>
      */
     template <class T>
-    struct value<T,
-                 type_traits::requires_t<type_traits::is_floating_point_v<T>>>
-        : type_traits::op
+      requires is_floating_point<T>
+    struct value<T> : value_base_<T>
     {
       /**
-       * @brief The type of the encapsulated value.
-       */
-      using value_type = T;
-
-      /**
-       * @brief The epsilon value used for floating point comparisons.
+       * @brief The epsilon value used for floating-point comparisons.
        *
        * @details
-       * This static inline member defines the precision for comparisons. It
-       * can be set explicitly via the constructor or computed as a default
-       * based on the number of decimal digits in the value.
+       * This instance member defines the precision for comparisons. It
+       * is set via the constructor, either explicitly or computed as a
+       * default based on the number of decimal digits in the value.
+       * Each instance carries its own epsilon, so two `value<T>` objects
+       * with different precisions do not interfere with each other.
        */
-      static inline auto epsilon = T{}; // Why static?
+      T epsilon = T{};
 
       /**
-       * @brief Constructs a floating point value with a specified precision.
+       * @brief Constructs a floating-point value with a specified precision.
        *
-       * @param _value The floating point value to be stored.
+       * @param _value The floating-point value to be stored.
        * @param precision The epsilon value to be used for comparisons.
        */
-      constexpr value (const T& _value, const T precision) : value_{ _value }
+      constexpr value (const T& _value, const T precision) noexcept
+          : value_base_<T>{ _value }, epsilon{ precision }
       {
-        epsilon = precision;
       }
 
       /**
@@ -1083,48 +812,13 @@ namespace micro_os_plus::micro_test_plus
        * The epsilon is computed as 1 divided by 10 raised to the number of
        * decimal digits in the value.
        */
-      constexpr /*explicit(false)*/ value (const T& val)
+      constexpr value (const T& val)
           : value{ val,
                    T (1)
                        / math::pow (T (10),
                                     math::den_size<unsigned long long> (val)) }
       {
       }
-
-      /**
-       * @brief Explicit conversion operator to the underlying value type.
-       *
-       * @return The stored value as type `T`.
-       *
-       * @details
-       * Allows explicit conversion to the encapsulated floating point value.
-       */
-      [[nodiscard]] constexpr explicit
-      operator T () const
-      {
-        return value_;
-      }
-
-      /**
-       * @brief Getter for the encapsulated value.
-       *
-       * @par Parameters
-       *	 None.
-       * @return The value of type `T`.
-       *
-       * @details
-       * Returns the stored floating point value.
-       */
-      [[nodiscard]] constexpr decltype (auto)
-      get (void) const
-      {
-        return value_;
-      }
-
-      /**
-       * @brief The encapsulated floating point value.
-       */
-      T value_{};
     };
 
     // ------------------------------------------------------------------------