From c0bc72c30ad59008de2eff0c9e72f83d25f3d91c Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmat@mail.ru>
Date: Tue, 3 Jan 2023 17:47:03 +0700
Subject: [PATCH] fix gcc10 building (remove same_as concept usage)

---
 headers/meta.hpp/meta_base/fixed_function.hpp |   6 +-
 headers/meta.hpp/meta_binds.hpp               |   4 +-
 headers/meta.hpp/meta_detail/index_family.hpp |  18 +-
 headers/meta.hpp/meta_detail/state_family.hpp |  18 +-
 headers/meta.hpp/meta_detail/type_family.hpp  |  28 +--
 headers/meta.hpp/meta_states.hpp              |  30 ++--
 headers/meta.hpp/meta_states/constructor.hpp  |   6 +-
 headers/meta.hpp/meta_states/function.hpp     |   8 +-
 headers/meta.hpp/meta_states/member.hpp       |   6 +-
 headers/meta.hpp/meta_states/method.hpp       |   8 +-
 headers/meta.hpp/meta_states/variable.hpp     |   6 +-
 headers/meta.hpp/meta_uvalue.hpp              |  12 +-
 headers/meta.hpp/meta_uvalue/uvalue.hpp       |  10 +-
 singles/headers/meta.hpp/meta_all.hpp         | 160 +++++++++---------
 untests/meta_utilities/detail_tests.cpp       |  42 ++---
 untests/meta_utilities/value3_tests.cpp       |  48 +++---
 untests/meta_utilities/value_tests.cpp        |   8 +-
 17 files changed, 209 insertions(+), 209 deletions(-)

diff --git a/headers/meta.hpp/meta_base/fixed_function.hpp b/headers/meta.hpp/meta_base/fixed_function.hpp
index 2464da2..6082423 100644
--- a/headers/meta.hpp/meta_base/fixed_function.hpp
+++ b/headers/meta.hpp/meta_base/fixed_function.hpp
@@ -38,14 +38,14 @@ namespace meta_hpp::detail
         }
 
         template < typename F >
-            requires (!std::same_as<fixed_function, std::decay_t<F>>)
+            requires (!std::is_same_v<fixed_function, std::decay_t<F>>)
         // NOLINTNEXTLINE(*-forwarding-reference-overload)
         fixed_function(F&& fun) {
             vtable_t::construct(*this, std::forward<F>(fun));
         }
 
         template < typename F >
-            requires (!std::same_as<fixed_function, std::decay_t<F>>)
+            requires (!std::is_same_v<fixed_function, std::decay_t<F>>)
         fixed_function& operator=(F&& fun) {
             fixed_function{std::forward<F>(fun)}.swap(*this);
             return *this;
@@ -111,7 +111,7 @@ namespace meta_hpp::detail
 
         template < typename Fp >
         static vtable_t* get() {
-            static_assert(std::same_as<Fp, std::decay_t<Fp>>);
+            static_assert(std::is_same_v<Fp, std::decay_t<Fp>>);
 
             static vtable_t table{
                 .call = +[](const fixed_function& self, Args... args) -> R {
diff --git a/headers/meta.hpp/meta_binds.hpp b/headers/meta.hpp/meta_binds.hpp
index 6aa92d1..fa5508d 100644
--- a/headers/meta.hpp/meta_binds.hpp
+++ b/headers/meta.hpp/meta_binds.hpp
@@ -32,12 +32,12 @@ namespace meta_hpp::detail
     template < typename Class, typename Member >
     concept class_bind_member_kind =
         class_kind<Class> && member_kind<Member> &&
-        std::same_as<Class, typename member_traits<Member>::class_type>;
+        std::is_same_v<Class, typename member_traits<Member>::class_type>;
 
     template < typename Class, typename Method >
     concept class_bind_method_kind =
         class_kind<Class> && method_kind<Method> &&
-        std::same_as<Class, typename method_traits<Method>::class_type>;
+        std::is_same_v<Class, typename method_traits<Method>::class_type>;
 }
 
 namespace meta_hpp
diff --git a/headers/meta.hpp/meta_detail/index_family.hpp b/headers/meta.hpp/meta_detail/index_family.hpp
index 8fdbb7a..7afb18a 100644
--- a/headers/meta.hpp/meta_detail/index_family.hpp
+++ b/headers/meta.hpp/meta_detail/index_family.hpp
@@ -12,13 +12,13 @@ namespace meta_hpp::detail
 {
     template < typename T >
     concept index_family =
-        std::same_as<T, argument_index> ||
-        std::same_as<T, constructor_index> ||
-        std::same_as<T, destructor_index> ||
-        std::same_as<T, evalue_index> ||
-        std::same_as<T, function_index> ||
-        std::same_as<T, member_index> ||
-        std::same_as<T, method_index> ||
-        std::same_as<T, scope_index> ||
-        std::same_as<T, variable_index>;
+        std::is_same_v<T, argument_index> ||
+        std::is_same_v<T, constructor_index> ||
+        std::is_same_v<T, destructor_index> ||
+        std::is_same_v<T, evalue_index> ||
+        std::is_same_v<T, function_index> ||
+        std::is_same_v<T, member_index> ||
+        std::is_same_v<T, method_index> ||
+        std::is_same_v<T, scope_index> ||
+        std::is_same_v<T, variable_index>;
 }
diff --git a/headers/meta.hpp/meta_detail/state_family.hpp b/headers/meta.hpp/meta_detail/state_family.hpp
index 4c33b18..2e971f5 100644
--- a/headers/meta.hpp/meta_detail/state_family.hpp
+++ b/headers/meta.hpp/meta_detail/state_family.hpp
@@ -12,15 +12,15 @@ namespace meta_hpp::detail
 {
     template < typename T >
     concept state_family =
-        std::same_as<T, argument> ||
-        std::same_as<T, constructor> ||
-        std::same_as<T, destructor> ||
-        std::same_as<T, evalue> ||
-        std::same_as<T, function> ||
-        std::same_as<T, member> ||
-        std::same_as<T, method> ||
-        std::same_as<T, scope> ||
-        std::same_as<T, variable>;
+        std::is_same_v<T, argument> ||
+        std::is_same_v<T, constructor> ||
+        std::is_same_v<T, destructor> ||
+        std::is_same_v<T, evalue> ||
+        std::is_same_v<T, function> ||
+        std::is_same_v<T, member> ||
+        std::is_same_v<T, method> ||
+        std::is_same_v<T, scope> ||
+        std::is_same_v<T, variable>;
 
     template < state_family T >
     [[nodiscard]] auto state_access(const T& state) {
diff --git a/headers/meta.hpp/meta_detail/type_family.hpp b/headers/meta.hpp/meta_detail/type_family.hpp
index 1baf5a1..2092180 100644
--- a/headers/meta.hpp/meta_detail/type_family.hpp
+++ b/headers/meta.hpp/meta_detail/type_family.hpp
@@ -12,20 +12,20 @@ namespace meta_hpp::detail
 {
     template < typename T >
     concept type_family =
-        std::same_as<T, any_type> ||
-        std::same_as<T, array_type> ||
-        std::same_as<T, class_type> ||
-        std::same_as<T, constructor_type> ||
-        std::same_as<T, destructor_type> ||
-        std::same_as<T, enum_type> ||
-        std::same_as<T, function_type> ||
-        std::same_as<T, member_type> ||
-        std::same_as<T, method_type> ||
-        std::same_as<T, nullptr_type> ||
-        std::same_as<T, number_type> ||
-        std::same_as<T, pointer_type> ||
-        std::same_as<T, reference_type> ||
-        std::same_as<T, void_type>;
+        std::is_same_v<T, any_type> ||
+        std::is_same_v<T, array_type> ||
+        std::is_same_v<T, class_type> ||
+        std::is_same_v<T, constructor_type> ||
+        std::is_same_v<T, destructor_type> ||
+        std::is_same_v<T, enum_type> ||
+        std::is_same_v<T, function_type> ||
+        std::is_same_v<T, member_type> ||
+        std::is_same_v<T, method_type> ||
+        std::is_same_v<T, nullptr_type> ||
+        std::is_same_v<T, number_type> ||
+        std::is_same_v<T, pointer_type> ||
+        std::is_same_v<T, reference_type> ||
+        std::is_same_v<T, void_type>;
 
     template < type_family T >
     [[nodiscard]] auto type_access(const T& type) {
diff --git a/headers/meta.hpp/meta_states.hpp b/headers/meta.hpp/meta_states.hpp
index 3b72e84..9609ef0 100644
--- a/headers/meta.hpp/meta_states.hpp
+++ b/headers/meta.hpp/meta_states.hpp
@@ -72,33 +72,33 @@ namespace meta_hpp
 
     template < typename Policy >
     concept constructor_policy_kind =
-        std::same_as<Policy, constructor_policy::as_object_t> ||
-        std::same_as<Policy, constructor_policy::as_raw_pointer_t> ||
-        std::same_as<Policy, constructor_policy::as_shared_pointer_t>;
+        std::is_same_v<Policy, constructor_policy::as_object_t> ||
+        std::is_same_v<Policy, constructor_policy::as_raw_pointer_t> ||
+        std::is_same_v<Policy, constructor_policy::as_shared_pointer_t>;
 
     template < typename Policy >
     concept function_policy_kind =
-        std::same_as<Policy, function_policy::as_copy_t> ||
-        std::same_as<Policy, function_policy::discard_return_t> ||
-        std::same_as<Policy, function_policy::return_reference_as_pointer_t>;
+        std::is_same_v<Policy, function_policy::as_copy_t> ||
+        std::is_same_v<Policy, function_policy::discard_return_t> ||
+        std::is_same_v<Policy, function_policy::return_reference_as_pointer_t>;
 
     template < typename Policy >
     concept member_policy_kind =
-        std::same_as<Policy, member_policy::as_copy_t> ||
-        std::same_as<Policy, member_policy::as_pointer_t> ||
-        std::same_as<Policy, member_policy::as_reference_wrapper_t>;
+        std::is_same_v<Policy, member_policy::as_copy_t> ||
+        std::is_same_v<Policy, member_policy::as_pointer_t> ||
+        std::is_same_v<Policy, member_policy::as_reference_wrapper_t>;
 
     template < typename Policy >
     concept method_policy_kind =
-        std::same_as<Policy, method_policy::as_copy_t> ||
-        std::same_as<Policy, method_policy::discard_return_t> ||
-        std::same_as<Policy, method_policy::return_reference_as_pointer_t>;
+        std::is_same_v<Policy, method_policy::as_copy_t> ||
+        std::is_same_v<Policy, method_policy::discard_return_t> ||
+        std::is_same_v<Policy, method_policy::return_reference_as_pointer_t>;
 
     template < typename Policy >
     concept variable_policy_kind =
-        std::same_as<Policy, variable_policy::as_copy_t> ||
-        std::same_as<Policy, variable_policy::as_pointer_t> ||
-        std::same_as<Policy, variable_policy::as_reference_wrapper_t>;
+        std::is_same_v<Policy, variable_policy::as_copy_t> ||
+        std::is_same_v<Policy, variable_policy::as_pointer_t> ||
+        std::is_same_v<Policy, variable_policy::as_reference_wrapper_t>;
 }
 
 namespace meta_hpp
diff --git a/headers/meta.hpp/meta_states/constructor.hpp b/headers/meta.hpp/meta_states/constructor.hpp
index 1cb8700..9a0e7d3 100644
--- a/headers/meta.hpp/meta_states/constructor.hpp
+++ b/headers/meta.hpp/meta_states/constructor.hpp
@@ -22,13 +22,13 @@ namespace meta_hpp::detail
 
         constexpr bool as_object =
             std::is_copy_constructible_v<class_type> &&
-            std::same_as<Policy, constructor_policy::as_object_t>;
+            std::is_same_v<Policy, constructor_policy::as_object_t>;
 
         constexpr bool as_raw_ptr =
-            std::same_as<Policy, constructor_policy::as_raw_pointer_t>;
+            std::is_same_v<Policy, constructor_policy::as_raw_pointer_t>;
 
         constexpr bool as_shared_ptr =
-            std::same_as<Policy, constructor_policy::as_shared_pointer_t>;
+            std::is_same_v<Policy, constructor_policy::as_shared_pointer_t>;
 
         static_assert(as_object || as_raw_ptr || as_shared_ptr);
 
diff --git a/headers/meta.hpp/meta_states/function.hpp b/headers/meta.hpp/meta_states/function.hpp
index 8dd33c4..5fcd59e 100644
--- a/headers/meta.hpp/meta_states/function.hpp
+++ b/headers/meta.hpp/meta_states/function.hpp
@@ -22,15 +22,15 @@ namespace meta_hpp::detail
 
         constexpr bool as_copy =
             std::is_copy_constructible_v<return_type> &&
-            std::same_as<Policy, function_policy::as_copy_t>;
+            std::is_same_v<Policy, function_policy::as_copy_t>;
 
         constexpr bool as_void =
             std::is_void_v<return_type> ||
-            std::same_as<Policy, function_policy::discard_return_t>;
+            std::is_same_v<Policy, function_policy::discard_return_t>;
 
         constexpr bool ref_as_ptr =
             std::is_reference_v<return_type> &&
-            std::same_as<Policy, function_policy::return_reference_as_pointer_t>;
+            std::is_same_v<Policy, function_policy::return_reference_as_pointer_t>;
 
         static_assert(as_copy || as_void || ref_as_ptr);
 
@@ -47,7 +47,7 @@ namespace meta_hpp::detail
                 function(
                     args[Is].cast<type_list_at_t<Is, argument_types>>()...);
                 return uvalue{};
-            } else if constexpr ( std::same_as<Policy, function_policy::discard_return_t> ) {
+            } else if constexpr ( std::is_same_v<Policy, function_policy::discard_return_t> ) {
                 std::ignore = function(
                     args[Is].cast<type_list_at_t<Is, argument_types>>()...);
                 return uvalue{};
diff --git a/headers/meta.hpp/meta_states/member.hpp b/headers/meta.hpp/meta_states/member.hpp
index 3a2c20f..0870d54 100644
--- a/headers/meta.hpp/meta_states/member.hpp
+++ b/headers/meta.hpp/meta_states/member.hpp
@@ -23,13 +23,13 @@ namespace meta_hpp::detail
 
         constexpr bool as_copy =
             std::is_copy_constructible_v<value_type> &&
-            std::same_as<Policy, member_policy::as_copy_t>;
+            std::is_same_v<Policy, member_policy::as_copy_t>;
 
         constexpr bool as_ptr =
-            std::same_as<Policy, member_policy::as_pointer_t>;
+            std::is_same_v<Policy, member_policy::as_pointer_t>;
 
         constexpr bool as_ref_wrap =
-            std::same_as<Policy, member_policy::as_reference_wrapper_t>;
+            std::is_same_v<Policy, member_policy::as_reference_wrapper_t>;
 
         static_assert(as_copy || as_ptr || as_ref_wrap);
 
diff --git a/headers/meta.hpp/meta_states/method.hpp b/headers/meta.hpp/meta_states/method.hpp
index 1cc31fb..b2b0f0f 100644
--- a/headers/meta.hpp/meta_states/method.hpp
+++ b/headers/meta.hpp/meta_states/method.hpp
@@ -24,15 +24,15 @@ namespace meta_hpp::detail
 
         constexpr bool as_copy =
             std::is_copy_constructible_v<return_type> &&
-            std::same_as<Policy, method_policy::as_copy_t>;
+            std::is_same_v<Policy, method_policy::as_copy_t>;
 
         constexpr bool as_void =
             std::is_void_v<return_type> ||
-            std::same_as<Policy, method_policy::discard_return_t>;
+            std::is_same_v<Policy, method_policy::discard_return_t>;
 
         constexpr bool ref_as_ptr =
             std::is_reference_v<return_type> &&
-            std::same_as<Policy, method_policy::return_reference_as_pointer_t>;
+            std::is_same_v<Policy, method_policy::return_reference_as_pointer_t>;
 
         static_assert(as_copy || as_void || ref_as_ptr);
 
@@ -53,7 +53,7 @@ namespace meta_hpp::detail
                 (inst.cast<qualified_type>().*method)(
                     args[Is].cast<type_list_at_t<Is, argument_types>>()...);
                 return uvalue{};
-            } else if constexpr ( std::same_as<Policy, method_policy::discard_return_t> ) {
+            } else if constexpr ( std::is_same_v<Policy, method_policy::discard_return_t> ) {
                 std::ignore = (inst.cast<qualified_type>().*method)(
                     args[Is].cast<type_list_at_t<Is, argument_types>>()...);
                 return uvalue{};
diff --git a/headers/meta.hpp/meta_states/variable.hpp b/headers/meta.hpp/meta_states/variable.hpp
index 02a6980..d40c679 100644
--- a/headers/meta.hpp/meta_states/variable.hpp
+++ b/headers/meta.hpp/meta_states/variable.hpp
@@ -21,13 +21,13 @@ namespace meta_hpp::detail
 
         constexpr bool as_copy =
             std::is_copy_constructible_v<data_type> &&
-            std::same_as<Policy, variable_policy::as_copy_t>;
+            std::is_same_v<Policy, variable_policy::as_copy_t>;
 
         constexpr bool as_ptr =
-            std::same_as<Policy, variable_policy::as_pointer_t>;
+            std::is_same_v<Policy, variable_policy::as_pointer_t>;
 
         constexpr bool as_ref_wrap =
-            std::same_as<Policy, variable_policy::as_reference_wrapper_t>;
+            std::is_same_v<Policy, variable_policy::as_reference_wrapper_t>;
 
         static_assert(as_copy || as_ptr || as_ref_wrap);
 
diff --git a/headers/meta.hpp/meta_uvalue.hpp b/headers/meta.hpp/meta_uvalue.hpp
index 5eec950..58ea6c3 100644
--- a/headers/meta.hpp/meta_uvalue.hpp
+++ b/headers/meta.hpp/meta_uvalue.hpp
@@ -13,15 +13,15 @@ namespace meta_hpp::detail
 {
     template < typename T >
     concept uvalue_kind
-        = std::same_as<T, uvalue>;
+        = std::is_same_v<T, uvalue>;
 
     template < typename T >
     concept any_uvalue_kind =
-        std::same_as<T, uarg_base> ||
-        std::same_as<T, uarg> ||
-        std::same_as<T, uinst_base> ||
-        std::same_as<T, uinst> ||
-        std::same_as<T, uvalue>;
+        std::is_same_v<T, uarg_base> ||
+        std::is_same_v<T, uarg> ||
+        std::is_same_v<T, uinst_base> ||
+        std::is_same_v<T, uinst> ||
+        std::is_same_v<T, uvalue>;
 }
 
 namespace meta_hpp
diff --git a/headers/meta.hpp/meta_uvalue/uvalue.hpp b/headers/meta.hpp/meta_uvalue/uvalue.hpp
index 071933e..bfcde4e 100644
--- a/headers/meta.hpp/meta_uvalue/uvalue.hpp
+++ b/headers/meta.hpp/meta_uvalue/uvalue.hpp
@@ -116,7 +116,7 @@ namespace meta_hpp
         template < typename Tp >
         // NOLINTNEXTLINE(*-cognitive-complexity)
         static vtable_t* get() {
-            static_assert(std::same_as<Tp, std::decay_t<Tp>>);
+            static_assert(std::is_same_v<Tp, std::decay_t<Tp>>);
 
             static vtable_t table{
                 .type = resolve_type<Tp>(),
@@ -348,7 +348,7 @@ namespace meta_hpp
 
     template < typename T >
     auto uvalue::get_as() -> std::conditional_t<detail::pointer_kind<T>, T, T&> {
-        static_assert(std::same_as<T, std::decay_t<T>>);
+        static_assert(std::is_same_v<T, std::decay_t<T>>);
 
         if constexpr ( detail::pointer_kind<T> ) {
             if ( T ptr = try_get_as<T>(); ptr || get_type().is_nullptr() ) {
@@ -365,7 +365,7 @@ namespace meta_hpp
 
     template < typename T >
     auto uvalue::get_as() const -> std::conditional_t<detail::pointer_kind<T>, T, const T&> {
-        static_assert(std::same_as<T, std::decay_t<T>>);
+        static_assert(std::is_same_v<T, std::decay_t<T>>);
 
         if constexpr ( detail::pointer_kind<T> ) {
             if ( T ptr = try_get_as<T>(); ptr || get_type().is_nullptr() ) {
@@ -383,7 +383,7 @@ namespace meta_hpp
     template < typename T >
     // NOLINTNEXTLINE(*-cognitive-complexity)
     auto uvalue::try_get_as() noexcept -> std::conditional_t<detail::pointer_kind<T>, T, T*> {
-        static_assert(std::same_as<T, std::decay_t<T>>);
+        static_assert(std::is_same_v<T, std::decay_t<T>>);
 
         const any_type& from_type = get_type();
         const any_type& to_type = resolve_type<T>();
@@ -448,7 +448,7 @@ namespace meta_hpp
     template < typename T >
     // NOLINTNEXTLINE(*-cognitive-complexity)
     auto uvalue::try_get_as() const noexcept -> std::conditional_t<detail::pointer_kind<T>, T, const T*> {
-        static_assert(std::same_as<T, std::decay_t<T>>);
+        static_assert(std::is_same_v<T, std::decay_t<T>>);
 
         const any_type& from_type = get_type();
         const any_type& to_type = resolve_type<T>();
diff --git a/singles/headers/meta.hpp/meta_all.hpp b/singles/headers/meta.hpp/meta_all.hpp
index d0de565..ec3580b 100644
--- a/singles/headers/meta.hpp/meta_all.hpp
+++ b/singles/headers/meta.hpp/meta_all.hpp
@@ -308,14 +308,14 @@ namespace meta_hpp::detail
         }
 
         template < typename F >
-            requires (!std::same_as<fixed_function, std::decay_t<F>>)
+            requires (!std::is_same_v<fixed_function, std::decay_t<F>>)
         // NOLINTNEXTLINE(*-forwarding-reference-overload)
         fixed_function(F&& fun) {
             vtable_t::construct(*this, std::forward<F>(fun));
         }
 
         template < typename F >
-            requires (!std::same_as<fixed_function, std::decay_t<F>>)
+            requires (!std::is_same_v<fixed_function, std::decay_t<F>>)
         fixed_function& operator=(F&& fun) {
             fixed_function{std::forward<F>(fun)}.swap(*this);
             return *this;
@@ -381,7 +381,7 @@ namespace meta_hpp::detail
 
         template < typename Fp >
         static vtable_t* get() {
-            static_assert(std::same_as<Fp, std::decay_t<Fp>>);
+            static_assert(std::is_same_v<Fp, std::decay_t<Fp>>);
 
             static vtable_t table{
                 .call = +[](const fixed_function& self, Args... args) -> R {
@@ -970,20 +970,20 @@ namespace meta_hpp::detail
 {
     template < typename T >
     concept type_family =
-        std::same_as<T, any_type> ||
-        std::same_as<T, array_type> ||
-        std::same_as<T, class_type> ||
-        std::same_as<T, constructor_type> ||
-        std::same_as<T, destructor_type> ||
-        std::same_as<T, enum_type> ||
-        std::same_as<T, function_type> ||
-        std::same_as<T, member_type> ||
-        std::same_as<T, method_type> ||
-        std::same_as<T, nullptr_type> ||
-        std::same_as<T, number_type> ||
-        std::same_as<T, pointer_type> ||
-        std::same_as<T, reference_type> ||
-        std::same_as<T, void_type>;
+        std::is_same_v<T, any_type> ||
+        std::is_same_v<T, array_type> ||
+        std::is_same_v<T, class_type> ||
+        std::is_same_v<T, constructor_type> ||
+        std::is_same_v<T, destructor_type> ||
+        std::is_same_v<T, enum_type> ||
+        std::is_same_v<T, function_type> ||
+        std::is_same_v<T, member_type> ||
+        std::is_same_v<T, method_type> ||
+        std::is_same_v<T, nullptr_type> ||
+        std::is_same_v<T, number_type> ||
+        std::is_same_v<T, pointer_type> ||
+        std::is_same_v<T, reference_type> ||
+        std::is_same_v<T, void_type>;
 
     template < type_family T >
     [[nodiscard]] auto type_access(const T& type) {
@@ -2091,15 +2091,15 @@ namespace meta_hpp::detail
 {
     template < typename T >
     concept index_family =
-        std::same_as<T, argument_index> ||
-        std::same_as<T, constructor_index> ||
-        std::same_as<T, destructor_index> ||
-        std::same_as<T, evalue_index> ||
-        std::same_as<T, function_index> ||
-        std::same_as<T, member_index> ||
-        std::same_as<T, method_index> ||
-        std::same_as<T, scope_index> ||
-        std::same_as<T, variable_index>;
+        std::is_same_v<T, argument_index> ||
+        std::is_same_v<T, constructor_index> ||
+        std::is_same_v<T, destructor_index> ||
+        std::is_same_v<T, evalue_index> ||
+        std::is_same_v<T, function_index> ||
+        std::is_same_v<T, member_index> ||
+        std::is_same_v<T, method_index> ||
+        std::is_same_v<T, scope_index> ||
+        std::is_same_v<T, variable_index>;
 }
 
 namespace meta_hpp
@@ -2283,15 +2283,15 @@ namespace meta_hpp::detail
 {
     template < typename T >
     concept uvalue_kind
-        = std::same_as<T, uvalue>;
+        = std::is_same_v<T, uvalue>;
 
     template < typename T >
     concept any_uvalue_kind =
-        std::same_as<T, uarg_base> ||
-        std::same_as<T, uarg> ||
-        std::same_as<T, uinst_base> ||
-        std::same_as<T, uinst> ||
-        std::same_as<T, uvalue>;
+        std::is_same_v<T, uarg_base> ||
+        std::is_same_v<T, uarg> ||
+        std::is_same_v<T, uinst_base> ||
+        std::is_same_v<T, uinst> ||
+        std::is_same_v<T, uvalue>;
 }
 
 namespace meta_hpp
@@ -2404,15 +2404,15 @@ namespace meta_hpp::detail
 {
     template < typename T >
     concept state_family =
-        std::same_as<T, argument> ||
-        std::same_as<T, constructor> ||
-        std::same_as<T, destructor> ||
-        std::same_as<T, evalue> ||
-        std::same_as<T, function> ||
-        std::same_as<T, member> ||
-        std::same_as<T, method> ||
-        std::same_as<T, scope> ||
-        std::same_as<T, variable>;
+        std::is_same_v<T, argument> ||
+        std::is_same_v<T, constructor> ||
+        std::is_same_v<T, destructor> ||
+        std::is_same_v<T, evalue> ||
+        std::is_same_v<T, function> ||
+        std::is_same_v<T, member> ||
+        std::is_same_v<T, method> ||
+        std::is_same_v<T, scope> ||
+        std::is_same_v<T, variable>;
 
     template < state_family T >
     [[nodiscard]] auto state_access(const T& state) {
@@ -2479,33 +2479,33 @@ namespace meta_hpp
 
     template < typename Policy >
     concept constructor_policy_kind =
-        std::same_as<Policy, constructor_policy::as_object_t> ||
-        std::same_as<Policy, constructor_policy::as_raw_pointer_t> ||
-        std::same_as<Policy, constructor_policy::as_shared_pointer_t>;
+        std::is_same_v<Policy, constructor_policy::as_object_t> ||
+        std::is_same_v<Policy, constructor_policy::as_raw_pointer_t> ||
+        std::is_same_v<Policy, constructor_policy::as_shared_pointer_t>;
 
     template < typename Policy >
     concept function_policy_kind =
-        std::same_as<Policy, function_policy::as_copy_t> ||
-        std::same_as<Policy, function_policy::discard_return_t> ||
-        std::same_as<Policy, function_policy::return_reference_as_pointer_t>;
+        std::is_same_v<Policy, function_policy::as_copy_t> ||
+        std::is_same_v<Policy, function_policy::discard_return_t> ||
+        std::is_same_v<Policy, function_policy::return_reference_as_pointer_t>;
 
     template < typename Policy >
     concept member_policy_kind =
-        std::same_as<Policy, member_policy::as_copy_t> ||
-        std::same_as<Policy, member_policy::as_pointer_t> ||
-        std::same_as<Policy, member_policy::as_reference_wrapper_t>;
+        std::is_same_v<Policy, member_policy::as_copy_t> ||
+        std::is_same_v<Policy, member_policy::as_pointer_t> ||
+        std::is_same_v<Policy, member_policy::as_reference_wrapper_t>;
 
     template < typename Policy >
     concept method_policy_kind =
-        std::same_as<Policy, method_policy::as_copy_t> ||
-        std::same_as<Policy, method_policy::discard_return_t> ||
-        std::same_as<Policy, method_policy::return_reference_as_pointer_t>;
+        std::is_same_v<Policy, method_policy::as_copy_t> ||
+        std::is_same_v<Policy, method_policy::discard_return_t> ||
+        std::is_same_v<Policy, method_policy::return_reference_as_pointer_t>;
 
     template < typename Policy >
     concept variable_policy_kind =
-        std::same_as<Policy, variable_policy::as_copy_t> ||
-        std::same_as<Policy, variable_policy::as_pointer_t> ||
-        std::same_as<Policy, variable_policy::as_reference_wrapper_t>;
+        std::is_same_v<Policy, variable_policy::as_copy_t> ||
+        std::is_same_v<Policy, variable_policy::as_pointer_t> ||
+        std::is_same_v<Policy, variable_policy::as_reference_wrapper_t>;
 }
 
 namespace meta_hpp
@@ -3253,12 +3253,12 @@ namespace meta_hpp::detail
     template < typename Class, typename Member >
     concept class_bind_member_kind =
         class_kind<Class> && member_kind<Member> &&
-        std::same_as<Class, typename member_traits<Member>::class_type>;
+        std::is_same_v<Class, typename member_traits<Member>::class_type>;
 
     template < typename Class, typename Method >
     concept class_bind_method_kind =
         class_kind<Class> && method_kind<Method> &&
-        std::same_as<Class, typename method_traits<Method>::class_type>;
+        std::is_same_v<Class, typename method_traits<Method>::class_type>;
 }
 
 namespace meta_hpp
@@ -5218,13 +5218,13 @@ namespace meta_hpp::detail
 
         constexpr bool as_object =
             std::is_copy_constructible_v<class_type> &&
-            std::same_as<Policy, constructor_policy::as_object_t>;
+            std::is_same_v<Policy, constructor_policy::as_object_t>;
 
         constexpr bool as_raw_ptr =
-            std::same_as<Policy, constructor_policy::as_raw_pointer_t>;
+            std::is_same_v<Policy, constructor_policy::as_raw_pointer_t>;
 
         constexpr bool as_shared_ptr =
-            std::same_as<Policy, constructor_policy::as_shared_pointer_t>;
+            std::is_same_v<Policy, constructor_policy::as_shared_pointer_t>;
 
         static_assert(as_object || as_raw_ptr || as_shared_ptr);
 
@@ -5757,15 +5757,15 @@ namespace meta_hpp::detail
 
         constexpr bool as_copy =
             std::is_copy_constructible_v<return_type> &&
-            std::same_as<Policy, function_policy::as_copy_t>;
+            std::is_same_v<Policy, function_policy::as_copy_t>;
 
         constexpr bool as_void =
             std::is_void_v<return_type> ||
-            std::same_as<Policy, function_policy::discard_return_t>;
+            std::is_same_v<Policy, function_policy::discard_return_t>;
 
         constexpr bool ref_as_ptr =
             std::is_reference_v<return_type> &&
-            std::same_as<Policy, function_policy::return_reference_as_pointer_t>;
+            std::is_same_v<Policy, function_policy::return_reference_as_pointer_t>;
 
         static_assert(as_copy || as_void || ref_as_ptr);
 
@@ -5782,7 +5782,7 @@ namespace meta_hpp::detail
                 function(
                     args[Is].cast<type_list_at_t<Is, argument_types>>()...);
                 return uvalue{};
-            } else if constexpr ( std::same_as<Policy, function_policy::discard_return_t> ) {
+            } else if constexpr ( std::is_same_v<Policy, function_policy::discard_return_t> ) {
                 std::ignore = function(
                     args[Is].cast<type_list_at_t<Is, argument_types>>()...);
                 return uvalue{};
@@ -6231,13 +6231,13 @@ namespace meta_hpp::detail
 
         constexpr bool as_copy =
             std::is_copy_constructible_v<value_type> &&
-            std::same_as<Policy, member_policy::as_copy_t>;
+            std::is_same_v<Policy, member_policy::as_copy_t>;
 
         constexpr bool as_ptr =
-            std::same_as<Policy, member_policy::as_pointer_t>;
+            std::is_same_v<Policy, member_policy::as_pointer_t>;
 
         constexpr bool as_ref_wrap =
-            std::same_as<Policy, member_policy::as_reference_wrapper_t>;
+            std::is_same_v<Policy, member_policy::as_reference_wrapper_t>;
 
         static_assert(as_copy || as_ptr || as_ref_wrap);
 
@@ -6528,15 +6528,15 @@ namespace meta_hpp::detail
 
         constexpr bool as_copy =
             std::is_copy_constructible_v<return_type> &&
-            std::same_as<Policy, method_policy::as_copy_t>;
+            std::is_same_v<Policy, method_policy::as_copy_t>;
 
         constexpr bool as_void =
             std::is_void_v<return_type> ||
-            std::same_as<Policy, method_policy::discard_return_t>;
+            std::is_same_v<Policy, method_policy::discard_return_t>;
 
         constexpr bool ref_as_ptr =
             std::is_reference_v<return_type> &&
-            std::same_as<Policy, method_policy::return_reference_as_pointer_t>;
+            std::is_same_v<Policy, method_policy::return_reference_as_pointer_t>;
 
         static_assert(as_copy || as_void || ref_as_ptr);
 
@@ -6557,7 +6557,7 @@ namespace meta_hpp::detail
                 (inst.cast<qualified_type>().*method)(
                     args[Is].cast<type_list_at_t<Is, argument_types>>()...);
                 return uvalue{};
-            } else if constexpr ( std::same_as<Policy, method_policy::discard_return_t> ) {
+            } else if constexpr ( std::is_same_v<Policy, method_policy::discard_return_t> ) {
                 std::ignore = (inst.cast<qualified_type>().*method)(
                     args[Is].cast<type_list_at_t<Is, argument_types>>()...);
                 return uvalue{};
@@ -6777,13 +6777,13 @@ namespace meta_hpp::detail
 
         constexpr bool as_copy =
             std::is_copy_constructible_v<data_type> &&
-            std::same_as<Policy, variable_policy::as_copy_t>;
+            std::is_same_v<Policy, variable_policy::as_copy_t>;
 
         constexpr bool as_ptr =
-            std::same_as<Policy, variable_policy::as_pointer_t>;
+            std::is_same_v<Policy, variable_policy::as_pointer_t>;
 
         constexpr bool as_ref_wrap =
-            std::same_as<Policy, variable_policy::as_reference_wrapper_t>;
+            std::is_same_v<Policy, variable_policy::as_reference_wrapper_t>;
 
         static_assert(as_copy || as_ptr || as_ref_wrap);
 
@@ -8210,7 +8210,7 @@ namespace meta_hpp
         template < typename Tp >
         // NOLINTNEXTLINE(*-cognitive-complexity)
         static vtable_t* get() {
-            static_assert(std::same_as<Tp, std::decay_t<Tp>>);
+            static_assert(std::is_same_v<Tp, std::decay_t<Tp>>);
 
             static vtable_t table{
                 .type = resolve_type<Tp>(),
@@ -8442,7 +8442,7 @@ namespace meta_hpp
 
     template < typename T >
     auto uvalue::get_as() -> std::conditional_t<detail::pointer_kind<T>, T, T&> {
-        static_assert(std::same_as<T, std::decay_t<T>>);
+        static_assert(std::is_same_v<T, std::decay_t<T>>);
 
         if constexpr ( detail::pointer_kind<T> ) {
             if ( T ptr = try_get_as<T>(); ptr || get_type().is_nullptr() ) {
@@ -8459,7 +8459,7 @@ namespace meta_hpp
 
     template < typename T >
     auto uvalue::get_as() const -> std::conditional_t<detail::pointer_kind<T>, T, const T&> {
-        static_assert(std::same_as<T, std::decay_t<T>>);
+        static_assert(std::is_same_v<T, std::decay_t<T>>);
 
         if constexpr ( detail::pointer_kind<T> ) {
             if ( T ptr = try_get_as<T>(); ptr || get_type().is_nullptr() ) {
@@ -8477,7 +8477,7 @@ namespace meta_hpp
     template < typename T >
     // NOLINTNEXTLINE(*-cognitive-complexity)
     auto uvalue::try_get_as() noexcept -> std::conditional_t<detail::pointer_kind<T>, T, T*> {
-        static_assert(std::same_as<T, std::decay_t<T>>);
+        static_assert(std::is_same_v<T, std::decay_t<T>>);
 
         const any_type& from_type = get_type();
         const any_type& to_type = resolve_type<T>();
@@ -8542,7 +8542,7 @@ namespace meta_hpp
     template < typename T >
     // NOLINTNEXTLINE(*-cognitive-complexity)
     auto uvalue::try_get_as() const noexcept -> std::conditional_t<detail::pointer_kind<T>, T, const T*> {
-        static_assert(std::same_as<T, std::decay_t<T>>);
+        static_assert(std::is_same_v<T, std::decay_t<T>>);
 
         const any_type& from_type = get_type();
         const any_type& to_type = resolve_type<T>();
diff --git a/untests/meta_utilities/detail_tests.cpp b/untests/meta_utilities/detail_tests.cpp
index 3293904..f80f88f 100644
--- a/untests/meta_utilities/detail_tests.cpp
+++ b/untests/meta_utilities/detail_tests.cpp
@@ -57,28 +57,28 @@ TEST_CASE("meta/meta_utilities/detail") {
     }
 
     SUBCASE("cvref_traits::copy_to") {
-        static_assert(std::same_as<meta::detail::cvref_traits<float>::copy_to<int>, int>);
-        static_assert(std::same_as<meta::detail::cvref_traits<const float>::copy_to<int>, const int>);
-        static_assert(std::same_as<meta::detail::cvref_traits<const volatile float>::copy_to<int>, const volatile int>);
-        static_assert(std::same_as<meta::detail::cvref_traits<float&>::copy_to<int>, int&>);
-        static_assert(std::same_as<meta::detail::cvref_traits<const float&>::copy_to<int>, const int&>);
-        static_assert(std::same_as<meta::detail::cvref_traits<volatile float&>::copy_to<int>, volatile int&>);
-        static_assert(std::same_as<meta::detail::cvref_traits<const volatile float&&>::copy_to<int>, const volatile int&&>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<float>::copy_to<int>, int>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<const float>::copy_to<int>, const int>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<const volatile float>::copy_to<int>, const volatile int>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<float&>::copy_to<int>, int&>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<const float&>::copy_to<int>, const int&>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<volatile float&>::copy_to<int>, volatile int&>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<const volatile float&&>::copy_to<int>, const volatile int&&>);
 
-        static_assert(std::same_as<meta::detail::cvref_traits<float>::copy_to<int&>, int>);
-        static_assert(std::same_as<meta::detail::cvref_traits<const float>::copy_to<int&>, const int>);
-        static_assert(std::same_as<meta::detail::cvref_traits<const volatile float>::copy_to<int&>, const volatile int>);
-        static_assert(std::same_as<meta::detail::cvref_traits<float&>::copy_to<int&>, int&>);
-        static_assert(std::same_as<meta::detail::cvref_traits<const float&>::copy_to<int&>, const int&>);
-        static_assert(std::same_as<meta::detail::cvref_traits<volatile float&>::copy_to<int&>, volatile int&>);
-        static_assert(std::same_as<meta::detail::cvref_traits<const volatile float&&>::copy_to<int&>, const volatile int&&>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<float>::copy_to<int&>, int>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<const float>::copy_to<int&>, const int>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<const volatile float>::copy_to<int&>, const volatile int>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<float&>::copy_to<int&>, int&>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<const float&>::copy_to<int&>, const int&>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<volatile float&>::copy_to<int&>, volatile int&>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<const volatile float&&>::copy_to<int&>, const volatile int&&>);
 
-        static_assert(std::same_as<meta::detail::cvref_traits<float>::copy_to<const volatile int&&>, int>);
-        static_assert(std::same_as<meta::detail::cvref_traits<const float>::copy_to<const volatile int&&>, const int>);
-        static_assert(std::same_as<meta::detail::cvref_traits<const volatile float>::copy_to<const volatile int&&>, const volatile int>);
-        static_assert(std::same_as<meta::detail::cvref_traits<float&>::copy_to<const volatile int&&>, int&>);
-        static_assert(std::same_as<meta::detail::cvref_traits<const float&>::copy_to<const volatile int&&>, const int&>);
-        static_assert(std::same_as<meta::detail::cvref_traits<volatile float&>::copy_to<const volatile int&&>, volatile int&>);
-        static_assert(std::same_as<meta::detail::cvref_traits<const volatile float&&>::copy_to<const volatile int&&>, const volatile int&&>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<float>::copy_to<const volatile int&&>, int>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<const float>::copy_to<const volatile int&&>, const int>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<const volatile float>::copy_to<const volatile int&&>, const volatile int>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<float&>::copy_to<const volatile int&&>, int&>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<const float&>::copy_to<const volatile int&&>, const int&>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<volatile float&>::copy_to<const volatile int&&>, volatile int&>);
+        static_assert(std::is_same_v<meta::detail::cvref_traits<const volatile float&&>::copy_to<const volatile int&&>, const volatile int&&>);
     }
 }
diff --git a/untests/meta_utilities/value3_tests.cpp b/untests/meta_utilities/value3_tests.cpp
index 4912a1a..3543c37 100644
--- a/untests/meta_utilities/value3_tests.cpp
+++ b/untests/meta_utilities/value3_tests.cpp
@@ -90,20 +90,20 @@ TEST_CASE("meta/meta_utilities/value4/get_type") {
 TEST_CASE("meta/meta_utilities/value4/get_as") {
     namespace meta = meta_hpp;
 
-    static_assert(std::same_as<decltype(std::declval<meta::uvalue&>().get_as<derived>()), derived&>);
-    static_assert(std::same_as<decltype(std::declval<meta::uvalue&&>().get_as<derived>()), derived&>);
-    static_assert(std::same_as<decltype(std::declval<const meta::uvalue&>().get_as<derived>()), const derived&>);
-    static_assert(std::same_as<decltype(std::declval<const meta::uvalue&&>().get_as<derived>()), const derived&>);
+    static_assert(std::is_same_v<decltype(std::declval<meta::uvalue&>().get_as<derived>()), derived&>);
+    static_assert(std::is_same_v<decltype(std::declval<meta::uvalue&&>().get_as<derived>()), derived&>);
+    static_assert(std::is_same_v<decltype(std::declval<const meta::uvalue&>().get_as<derived>()), const derived&>);
+    static_assert(std::is_same_v<decltype(std::declval<const meta::uvalue&&>().get_as<derived>()), const derived&>);
 
-    static_assert(std::same_as<decltype(std::declval<meta::uvalue&>().get_as<derived*>()), derived*>);
-    static_assert(std::same_as<decltype(std::declval<meta::uvalue&&>().get_as<derived*>()), derived*>);
-    static_assert(std::same_as<decltype(std::declval<const meta::uvalue&>().get_as<derived*>()), derived*>);
-    static_assert(std::same_as<decltype(std::declval<const meta::uvalue&&>().get_as<derived*>()), derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<meta::uvalue&>().get_as<derived*>()), derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<meta::uvalue&&>().get_as<derived*>()), derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<const meta::uvalue&>().get_as<derived*>()), derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<const meta::uvalue&&>().get_as<derived*>()), derived*>);
 
-    static_assert(std::same_as<decltype(std::declval<meta::uvalue&>().get_as<const derived*>()), const derived*>);
-    static_assert(std::same_as<decltype(std::declval<meta::uvalue&&>().get_as<const derived*>()), const derived*>);
-    static_assert(std::same_as<decltype(std::declval<const meta::uvalue&>().get_as<const derived*>()), const derived*>);
-    static_assert(std::same_as<decltype(std::declval<const meta::uvalue&&>().get_as<const derived*>()), const derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<meta::uvalue&>().get_as<const derived*>()), const derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<meta::uvalue&&>().get_as<const derived*>()), const derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<const meta::uvalue&>().get_as<const derived*>()), const derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<const meta::uvalue&&>().get_as<const derived*>()), const derived*>);
 
     SUBCASE("derived to derived") {
         {
@@ -209,20 +209,20 @@ TEST_CASE("meta/meta_utilities/value4/get_as") {
 TEST_CASE("meta/meta_utilities/value4/try_get_as") {
     namespace meta = meta_hpp;
 
-    static_assert(std::same_as<decltype(std::declval<meta::uvalue&>().try_get_as<derived>()), derived*>);
-    static_assert(std::same_as<decltype(std::declval<meta::uvalue&&>().try_get_as<derived>()), derived*>);
-    static_assert(std::same_as<decltype(std::declval<const meta::uvalue&>().try_get_as<derived>()), const derived*>);
-    static_assert(std::same_as<decltype(std::declval<const meta::uvalue&&>().try_get_as<derived>()), const derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<meta::uvalue&>().try_get_as<derived>()), derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<meta::uvalue&&>().try_get_as<derived>()), derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<const meta::uvalue&>().try_get_as<derived>()), const derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<const meta::uvalue&&>().try_get_as<derived>()), const derived*>);
 
-    static_assert(std::same_as<decltype(std::declval<meta::uvalue&>().try_get_as<derived*>()), derived*>);
-    static_assert(std::same_as<decltype(std::declval<meta::uvalue&&>().try_get_as<derived*>()), derived*>);
-    static_assert(std::same_as<decltype(std::declval<const meta::uvalue&>().try_get_as<derived*>()), derived*>);
-    static_assert(std::same_as<decltype(std::declval<const meta::uvalue&&>().try_get_as<derived*>()), derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<meta::uvalue&>().try_get_as<derived*>()), derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<meta::uvalue&&>().try_get_as<derived*>()), derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<const meta::uvalue&>().try_get_as<derived*>()), derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<const meta::uvalue&&>().try_get_as<derived*>()), derived*>);
 
-    static_assert(std::same_as<decltype(std::declval<meta::uvalue&>().try_get_as<const derived*>()), const derived*>);
-    static_assert(std::same_as<decltype(std::declval<meta::uvalue&&>().try_get_as<const derived*>()), const derived*>);
-    static_assert(std::same_as<decltype(std::declval<const meta::uvalue&>().try_get_as<const derived*>()), const derived*>);
-    static_assert(std::same_as<decltype(std::declval<const meta::uvalue&&>().try_get_as<const derived*>()), const derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<meta::uvalue&>().try_get_as<const derived*>()), const derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<meta::uvalue&&>().try_get_as<const derived*>()), const derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<const meta::uvalue&>().try_get_as<const derived*>()), const derived*>);
+    static_assert(std::is_same_v<decltype(std::declval<const meta::uvalue&&>().try_get_as<const derived*>()), const derived*>);
 
     SUBCASE("derived to derived") {
         {
diff --git a/untests/meta_utilities/value_tests.cpp b/untests/meta_utilities/value_tests.cpp
index 8d33b76..da1e61f 100644
--- a/untests/meta_utilities/value_tests.cpp
+++ b/untests/meta_utilities/value_tests.cpp
@@ -104,16 +104,16 @@ TEST_CASE("meta/meta_utilities/value") {
     ivec2::copy_constructor_counter = 0;
 
     SUBCASE("cast types") {
-        static_assert(std::same_as<
+        static_assert(std::is_same_v<
             decltype(std::declval<meta::uvalue&>().get_as<ivec2>()),
             ivec2&>);
-        static_assert(std::same_as<
+        static_assert(std::is_same_v<
             decltype(std::declval<meta::uvalue&&>().get_as<ivec2>()),
             ivec2&>);
-        static_assert(std::same_as<
+        static_assert(std::is_same_v<
             decltype(std::declval<const meta::uvalue&>().get_as<ivec2>()),
             const ivec2&>);
-        static_assert(std::same_as<
+        static_assert(std::is_same_v<
             decltype(std::declval<const meta::uvalue&&>().get_as<ivec2>()),
             const ivec2&>);
     }