diff --git a/develop/singles/headers/meta.hpp/meta_all.hpp b/develop/singles/headers/meta.hpp/meta_all.hpp
index bde6136..fb15d5a 100644
--- a/develop/singles/headers/meta.hpp/meta_all.hpp
+++ b/develop/singles/headers/meta.hpp/meta_all.hpp
@@ -1444,6 +1444,19 @@ namespace meta_hpp
         class uinst_base;
         class uinst;
     }
+
+    namespace detail
+    {
+        template < typename T >
+        concept uvalue_family               //
+            = 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, uerror>     //
+           || std::is_same_v<T, uresult>    //
+           || std::is_same_v<T, uvalue>;    //
+    }
 }
 
 namespace meta_hpp
@@ -1480,6 +1493,21 @@ namespace meta_hpp
         using scope_state_ptr = intrusive_ptr<scope_state>;
         using variable_state_ptr = intrusive_ptr<variable_state>;
     }
+
+    namespace detail
+    {
+        template < typename T >
+        concept state_family                 //
+            = 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>;   //
+    }
 }
 
 namespace meta_hpp
@@ -1516,6 +1544,26 @@ namespace meta_hpp
         struct reference_type_data;
         struct void_type_data;
     }
+
+    namespace detail
+    {
+        template < typename T >
+        concept type_family                       //
+            = 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>;       //
+    }
 }
 
 namespace meta_hpp
@@ -1529,6 +1577,21 @@ namespace meta_hpp
     class method_index;
     class scope_index;
     class variable_index;
+
+    namespace detail
+    {
+        template < typename T >
+        concept index_family                       //
+            = 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
@@ -2061,23 +2124,6 @@ namespace meta_hpp::detail
 
 namespace meta_hpp::detail
 {
-    template < typename T >
-    concept type_family                       //
-        = 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 Type>
     struct type_traits;
 
@@ -2666,21 +2712,6 @@ namespace meta_hpp::detail
     };
 }
 
-namespace meta_hpp::detail
-{
-    template < typename T >
-    concept index_family                       //
-        = 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
 {
     class argument_index final {
@@ -2874,7 +2905,7 @@ namespace meta_hpp
             typename T,                            //
             typename Tp = std::decay_t<T>,         //
             typename = std::enable_if_t<           //
-                !std::is_same_v<Tp, uvalue> &&     //
+                !detail::uvalue_family<Tp> &&      //
                 !detail::is_in_place_type_v<Tp> && //
                 std::is_copy_constructible_v<Tp>>> //
         uvalue(T&& val);
@@ -2883,7 +2914,7 @@ namespace meta_hpp
             typename T,                            //
             typename Tp = std::decay_t<T>,         //
             typename = std::enable_if_t<           //
-                !std::is_same_v<Tp, uvalue> &&     //
+                !detail::uvalue_family<Tp> &&      //
                 std::is_copy_constructible_v<Tp>>> //
         uvalue& operator=(T&& val);
 
@@ -3095,9 +3126,7 @@ namespace meta_hpp
             typename T,                            //
             typename Tp = std::decay_t<T>,         //
             typename = std::enable_if_t<           //
-                !std::is_same_v<Tp, uerror> &&     //
-                !std::is_same_v<Tp, uvalue> &&     //
-                !std::is_same_v<Tp, uresult> &&    //
+                !detail::uvalue_family<Tp> &&      //
                 !detail::is_in_place_type_v<Tp> && //
                 std::is_copy_constructible_v<Tp>>> //
         uresult(T&& val);
@@ -3106,9 +3135,7 @@ namespace meta_hpp
             typename T,                            //
             typename Tp = std::decay_t<T>,         //
             typename = std::enable_if_t<           //
-                !std::is_same_v<Tp, uerror> &&     //
-                !std::is_same_v<Tp, uvalue> &&     //
-                !std::is_same_v<Tp, uresult> &&    //
+                !detail::uvalue_family<Tp> &&      //
                 std::is_copy_constructible_v<Tp>>> //
         uresult& operator=(T&& val);
 
@@ -3176,18 +3203,6 @@ namespace meta_hpp
 
 namespace meta_hpp::detail
 {
-    template < typename T >
-    concept state_family                 //
-        = 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 State >
     struct state_traits;
 
@@ -5343,28 +5358,16 @@ namespace meta_hpp
     bool is_invocable_with(Method, Instance&& instance, Args&&... args);
 }
 
-namespace meta_hpp::detail
-{
-    template < typename T >
-    concept any_uvalue_kind             //
-        = 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, uresult>    //
-       || std::is_same_v<T, uvalue>;    //
-}
-
 namespace meta_hpp::detail
 {
     template < typename T, typename Tp = std::decay_t<T> >
-    concept arg_lvalue_ref_kind  //
-        = (!any_uvalue_kind<Tp>) //
+    concept arg_lvalue_ref_kind //
+        = (!uvalue_family<Tp>)  //
        && (std::is_lvalue_reference_v<T>);
 
     template < typename T, typename Tp = std::decay_t<T> >
-    concept arg_rvalue_ref_kind  //
-        = (!any_uvalue_kind<Tp>) //
+    concept arg_rvalue_ref_kind //
+        = (!uvalue_family<Tp>)  //
        && (!std::is_reference_v<T> || std::is_rvalue_reference_v<T>);
 }
 
@@ -5377,13 +5380,13 @@ namespace meta_hpp::detail
 
     template < typename T, typename Tp = std::decay_t<T> >
     concept inst_class_lvalue_ref_kind    //
-        = (!any_uvalue_kind<Tp>)          //
+        = (!uvalue_family<Tp>)            //
        && (std::is_lvalue_reference_v<T>) //
        && (std::is_class_v<std::remove_pointer_t<std::remove_reference_t<T>>>);
 
     template < typename T, typename Tp = std::decay_t<T> >
     concept inst_class_rvalue_ref_kind                               //
-        = (!any_uvalue_kind<Tp>)                                     //
+        = (!uvalue_family<Tp>)                                       //
        && (!std::is_reference_v<T> || std::is_rvalue_reference_v<T>) //
        && (std::is_class_v<std::remove_pointer_t<std::remove_reference_t<T>>>);
 }
@@ -5552,7 +5555,7 @@ namespace meta_hpp::detail
         uarg_base& operator=(const uarg_base&) = delete;
 
         template < typename T, typename Tp = std::decay_t<T> >
-            requires(!any_uvalue_kind<Tp>)
+            requires(!uvalue_family<Tp>)
         explicit uarg_base(type_registry& registry, T&&)
         : uarg_base{registry, type_list<T&&>{}} {}
 
@@ -5582,6 +5585,11 @@ namespace meta_hpp::detail
         : ref_type_{ref_types::const_rvalue}
         , raw_type_{v.get_type()} {}
 
+        template < typename T, typename Tp = std::decay_t<T> >
+            requires std::is_same_v<Tp, uresult>
+        explicit uarg_base(type_registry& registry, T&& v)
+        : uarg_base{registry, *std::forward<T>(v)} {}
+
         [[nodiscard]] bool is_ref_const() const noexcept {
             return ref_type_ == ref_types::const_lvalue //
                 || ref_type_ == ref_types::const_rvalue;
@@ -5629,7 +5637,13 @@ namespace meta_hpp::detail
         , data_{const_cast<void*>(v.get_data())} {} // NOLINT(*-const-cast)
 
         template < typename T, typename Tp = std::decay_t<T> >
-            requires(!any_uvalue_kind<Tp>)
+            requires std::is_same_v<Tp, uresult>
+        explicit uarg(type_registry& registry, T&& v)
+        : uarg_base{registry, std::forward<T>(v)}
+        , data_{const_cast<void*>(v->get_data())} {} // NOLINT(*-const-cast)
+
+        template < typename T, typename Tp = std::decay_t<T> >
+            requires(!uvalue_family<Tp>)
         explicit uarg(type_registry& registry, T&& v)
         : uarg_base{registry, std::forward<T>(v)}
         , data_{const_cast<std::remove_cvref_t<T>*>(std::addressof(v))} {} // NOLINT(*-const-cast)
@@ -6115,7 +6129,7 @@ namespace meta_hpp::detail
         uinst_base& operator=(const uinst_base&) = delete;
 
         template < typename T, typename Tp = std::decay_t<T> >
-            requires(!any_uvalue_kind<Tp>)
+            requires(!uvalue_family<Tp>)
         explicit uinst_base(type_registry& registry, T&&)
         : uinst_base{registry, type_list<T&&>{}} {}
 
@@ -6145,6 +6159,11 @@ namespace meta_hpp::detail
         : ref_type_{ref_types::const_rvalue}
         , raw_type_{v.get_type()} {}
 
+        template < typename T, typename Tp = std::decay_t<T> >
+            requires std::is_same_v<Tp, uresult>
+        explicit uinst_base(type_registry& registry, T&& v)
+        : uinst_base{registry, *std::forward<T>(v)} {}
+
         [[nodiscard]] bool is_inst_const() const noexcept {
             if ( raw_type_.is_pointer() ) {
                 const pointer_type& from_type_ptr = raw_type_.as_pointer();
@@ -6192,7 +6211,13 @@ namespace meta_hpp::detail
         , data_{const_cast<void*>(v.get_data())} {} // NOLINT(*-const-cast)
 
         template < typename T, typename Tp = std::decay_t<T> >
-            requires(!any_uvalue_kind<Tp>)
+            requires std::is_same_v<Tp, uresult>
+        explicit uinst(type_registry& registry, T&& v)
+        : uinst_base{registry, std::forward<T>(v)}
+        , data_{const_cast<void*>(v->get_data())} {} // NOLINT(*-const-cast)
+
+        template < typename T, typename Tp = std::decay_t<T> >
+            requires(!uvalue_family<Tp>)
         explicit uinst(type_registry& registry, T&& v)
         : uinst_base{registry, std::forward<T>(v)}
         , data_{const_cast<std::remove_cvref_t<T>*>(std::addressof(v))} {} // NOLINT(*-const-cast)
diff --git a/develop/untests/meta_utilities/invoke_tests.cpp b/develop/untests/meta_utilities/invoke_tests.cpp
index b6b0fdf..ccc3f2c 100644
--- a/develop/untests/meta_utilities/invoke_tests.cpp
+++ b/develop/untests/meta_utilities/invoke_tests.cpp
@@ -35,15 +35,19 @@ TEST_CASE("meta/meta_utilities/invoke") {
     {
         CHECK(meta::invoke(&clazz::function, 3).as<int>() == 3);
         CHECK(meta::invoke(&clazz::function, meta::uvalue{3}).as<int>() == 3);
+        CHECK(meta::invoke(&clazz::function, meta::uresult{3}).as<int>() == 3);
         CHECK(meta::invoke(clazz_function, 3).as<int>() == 3);
         CHECK(meta::invoke(clazz_function, meta::uvalue{3}).as<int>() == 3);
+        CHECK(meta::invoke(clazz_function, meta::uresult{3}).as<int>() == 3);
 
         CHECK(meta::is_invocable_with(clazz_function, 3));
         CHECK(meta::is_invocable_with(clazz_function, meta::uvalue{3}));
+        CHECK(meta::is_invocable_with(clazz_function, meta::uresult{3}));
         CHECK(meta::is_invocable_with<int>(clazz_function));
 
         CHECK(meta::is_invocable_with(&clazz::function, 3));
         CHECK(meta::is_invocable_with(&clazz::function, meta::uvalue{3}));
+        CHECK(meta::is_invocable_with(&clazz::function, meta::uresult{3}));
         CHECK(meta::is_invocable_with<int>(&clazz::function));
     }
 
@@ -52,15 +56,19 @@ TEST_CASE("meta/meta_utilities/invoke") {
 
         CHECK(meta::invoke(&clazz::member, cl).as<int>() == 1);
         CHECK(meta::invoke(&clazz::member, meta::uvalue{cl}).as<int>() == 1);
+        CHECK(meta::invoke(&clazz::member, meta::uresult{cl}).as<int>() == 1);
         CHECK(meta::invoke(clazz_member, cl).as<int>() == 1);
         CHECK(meta::invoke(clazz_member, meta::uvalue{cl}).as<int>() == 1);
+        CHECK(meta::invoke(clazz_member, meta::uresult{cl}).as<int>() == 1);
 
         CHECK(meta::is_invocable_with(clazz_member, cl));
         CHECK(meta::is_invocable_with(clazz_member, meta::uvalue{cl}));
+        CHECK(meta::is_invocable_with(clazz_member, meta::uresult{cl}));
         CHECK(meta::is_invocable_with<const clazz&>(clazz_member));
 
         CHECK(meta::is_invocable_with(&clazz::member, cl));
         CHECK(meta::is_invocable_with(&clazz::member, meta::uvalue{cl}));
+        CHECK(meta::is_invocable_with(&clazz::member, meta::uresult{cl}));
         CHECK(meta::is_invocable_with<const clazz&>(&clazz::member));
     }
 
@@ -69,15 +77,19 @@ TEST_CASE("meta/meta_utilities/invoke") {
 
         CHECK(meta::invoke(&clazz::method, cl, 2).as<int>() == 2);
         CHECK(meta::invoke(&clazz::method, meta::uvalue{cl}, meta::uvalue{2}).as<int>() == 2);
+        CHECK(meta::invoke(&clazz::method, meta::uresult{cl}, meta::uresult{2}).as<int>() == 2);
         CHECK(meta::invoke(clazz_method, cl, 2).as<int>() == 2);
         CHECK(meta::invoke(clazz_method, meta::uvalue{cl}, meta::uvalue{2}).as<int>() == 2);
+        CHECK(meta::invoke(clazz_method, meta::uresult{cl}, meta::uresult{2}).as<int>() == 2);
 
         CHECK(meta::is_invocable_with(clazz_method, cl, 2));
         CHECK(meta::is_invocable_with(clazz_method, meta::uvalue{cl}, meta::uvalue{2}));
+        CHECK(meta::is_invocable_with(clazz_method, meta::uresult{cl}, meta::uresult{2}));
         CHECK(meta::is_invocable_with<const clazz&, int>(clazz_method));
 
         CHECK(meta::is_invocable_with(&clazz::method, cl, 2));
         CHECK(meta::is_invocable_with(&clazz::method, meta::uvalue{cl}, meta::uvalue{2}));
+        CHECK(meta::is_invocable_with(&clazz::method, meta::uresult{cl}, meta::uresult{2}));
         CHECK(meta::is_invocable_with<const clazz&, int>(&clazz::method));
     }
 }
diff --git a/headers/meta.hpp/meta_base.hpp b/headers/meta.hpp/meta_base.hpp
index 352c9a3..dc3fa47 100644
--- a/headers/meta.hpp/meta_base.hpp
+++ b/headers/meta.hpp/meta_base.hpp
@@ -61,6 +61,19 @@ namespace meta_hpp
         class uinst_base;
         class uinst;
     }
+
+    namespace detail
+    {
+        template < typename T >
+        concept uvalue_family               //
+            = 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, uerror>     //
+           || std::is_same_v<T, uresult>    //
+           || std::is_same_v<T, uvalue>;    //
+    }
 }
 
 namespace meta_hpp
@@ -97,6 +110,21 @@ namespace meta_hpp
         using scope_state_ptr = intrusive_ptr<scope_state>;
         using variable_state_ptr = intrusive_ptr<variable_state>;
     }
+
+    namespace detail
+    {
+        template < typename T >
+        concept state_family                 //
+            = 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>;   //
+    }
 }
 
 namespace meta_hpp
@@ -133,6 +161,26 @@ namespace meta_hpp
         struct reference_type_data;
         struct void_type_data;
     }
+
+    namespace detail
+    {
+        template < typename T >
+        concept type_family                       //
+            = 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>;       //
+    }
 }
 
 namespace meta_hpp
@@ -146,6 +194,21 @@ namespace meta_hpp
     class method_index;
     class scope_index;
     class variable_index;
+
+    namespace detail
+    {
+        template < typename T >
+        concept index_family                       //
+            = 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
diff --git a/headers/meta.hpp/meta_detail/index_family.hpp b/headers/meta.hpp/meta_detail/index_family.hpp
deleted file mode 100644
index 9e5381d..0000000
--- a/headers/meta.hpp/meta_detail/index_family.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/*******************************************************************************
- * This file is part of the "https://github.com/blackmatov/meta.hpp"
- * For conditions of distribution and use, see copyright notice in LICENSE.md
- * Copyright (C) 2021-2023, by Matvey Cherevko (blackmatov@gmail.com)
- ******************************************************************************/
-
-#pragma once
-
-#include "../meta_base.hpp"
-
-namespace meta_hpp::detail
-{
-    template < typename T >
-    concept index_family                       //
-        = 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 3cc7d26..5272ec4 100644
--- a/headers/meta.hpp/meta_detail/state_family.hpp
+++ b/headers/meta.hpp/meta_detail/state_family.hpp
@@ -10,18 +10,6 @@
 
 namespace meta_hpp::detail
 {
-    template < typename T >
-    concept state_family                 //
-        = 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 State >
     struct state_traits;
 
diff --git a/headers/meta.hpp/meta_detail/type_family.hpp b/headers/meta.hpp/meta_detail/type_family.hpp
index 98ef0d5..2d8b8b2 100644
--- a/headers/meta.hpp/meta_detail/type_family.hpp
+++ b/headers/meta.hpp/meta_detail/type_family.hpp
@@ -22,23 +22,6 @@
 
 namespace meta_hpp::detail
 {
-    template < typename T >
-    concept type_family                       //
-        = 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 Type>
     struct type_traits;
 
diff --git a/headers/meta.hpp/meta_detail/value_utilities/uarg.hpp b/headers/meta.hpp/meta_detail/value_utilities/uarg.hpp
index 4c7b7d1..d98ce22 100644
--- a/headers/meta.hpp/meta_detail/value_utilities/uarg.hpp
+++ b/headers/meta.hpp/meta_detail/value_utilities/uarg.hpp
@@ -8,6 +8,7 @@
 
 #include "../../meta_base.hpp"
 #include "../../meta_registry.hpp"
+#include "../../meta_uresult.hpp"
 #include "../../meta_uvalue.hpp"
 
 #include "utraits.hpp"
@@ -34,7 +35,7 @@ namespace meta_hpp::detail
         uarg_base& operator=(const uarg_base&) = delete;
 
         template < typename T, typename Tp = std::decay_t<T> >
-            requires(!any_uvalue_kind<Tp>)
+            requires(!uvalue_family<Tp>)
         explicit uarg_base(type_registry& registry, T&&)
         : uarg_base{registry, type_list<T&&>{}} {}
 
@@ -64,6 +65,11 @@ namespace meta_hpp::detail
         : ref_type_{ref_types::const_rvalue}
         , raw_type_{v.get_type()} {}
 
+        template < typename T, typename Tp = std::decay_t<T> >
+            requires std::is_same_v<Tp, uresult>
+        explicit uarg_base(type_registry& registry, T&& v)
+        : uarg_base{registry, *std::forward<T>(v)} {}
+
         [[nodiscard]] bool is_ref_const() const noexcept {
             return ref_type_ == ref_types::const_lvalue //
                 || ref_type_ == ref_types::const_rvalue;
@@ -111,7 +117,13 @@ namespace meta_hpp::detail
         , data_{const_cast<void*>(v.get_data())} {} // NOLINT(*-const-cast)
 
         template < typename T, typename Tp = std::decay_t<T> >
-            requires(!any_uvalue_kind<Tp>)
+            requires std::is_same_v<Tp, uresult>
+        explicit uarg(type_registry& registry, T&& v)
+        : uarg_base{registry, std::forward<T>(v)}
+        , data_{const_cast<void*>(v->get_data())} {} // NOLINT(*-const-cast)
+
+        template < typename T, typename Tp = std::decay_t<T> >
+            requires(!uvalue_family<Tp>)
         explicit uarg(type_registry& registry, T&& v)
         : uarg_base{registry, std::forward<T>(v)}
         , data_{const_cast<std::remove_cvref_t<T>*>(std::addressof(v))} {} // NOLINT(*-const-cast)
diff --git a/headers/meta.hpp/meta_detail/value_utilities/uinst.hpp b/headers/meta.hpp/meta_detail/value_utilities/uinst.hpp
index 1ee40a0..efff60e 100644
--- a/headers/meta.hpp/meta_detail/value_utilities/uinst.hpp
+++ b/headers/meta.hpp/meta_detail/value_utilities/uinst.hpp
@@ -8,6 +8,7 @@
 
 #include "../../meta_base.hpp"
 #include "../../meta_registry.hpp"
+#include "../../meta_uresult.hpp"
 #include "../../meta_uvalue.hpp"
 
 #include "utraits.hpp"
@@ -34,7 +35,7 @@ namespace meta_hpp::detail
         uinst_base& operator=(const uinst_base&) = delete;
 
         template < typename T, typename Tp = std::decay_t<T> >
-            requires(!any_uvalue_kind<Tp>)
+            requires(!uvalue_family<Tp>)
         explicit uinst_base(type_registry& registry, T&&)
         : uinst_base{registry, type_list<T&&>{}} {}
 
@@ -64,6 +65,11 @@ namespace meta_hpp::detail
         : ref_type_{ref_types::const_rvalue}
         , raw_type_{v.get_type()} {}
 
+        template < typename T, typename Tp = std::decay_t<T> >
+            requires std::is_same_v<Tp, uresult>
+        explicit uinst_base(type_registry& registry, T&& v)
+        : uinst_base{registry, *std::forward<T>(v)} {}
+
         [[nodiscard]] bool is_inst_const() const noexcept {
             if ( raw_type_.is_pointer() ) {
                 const pointer_type& from_type_ptr = raw_type_.as_pointer();
@@ -111,7 +117,13 @@ namespace meta_hpp::detail
         , data_{const_cast<void*>(v.get_data())} {} // NOLINT(*-const-cast)
 
         template < typename T, typename Tp = std::decay_t<T> >
-            requires(!any_uvalue_kind<Tp>)
+            requires std::is_same_v<Tp, uresult>
+        explicit uinst(type_registry& registry, T&& v)
+        : uinst_base{registry, std::forward<T>(v)}
+        , data_{const_cast<void*>(v->get_data())} {} // NOLINT(*-const-cast)
+
+        template < typename T, typename Tp = std::decay_t<T> >
+            requires(!uvalue_family<Tp>)
         explicit uinst(type_registry& registry, T&& v)
         : uinst_base{registry, std::forward<T>(v)}
         , data_{const_cast<std::remove_cvref_t<T>*>(std::addressof(v))} {} // NOLINT(*-const-cast)
diff --git a/headers/meta.hpp/meta_detail/value_utilities/utraits.hpp b/headers/meta.hpp/meta_detail/value_utilities/utraits.hpp
index 54a7016..c76b4a7 100644
--- a/headers/meta.hpp/meta_detail/value_utilities/utraits.hpp
+++ b/headers/meta.hpp/meta_detail/value_utilities/utraits.hpp
@@ -8,30 +8,17 @@
 
 #include "../../meta_base.hpp"
 #include "../../meta_registry.hpp"
-#include "../../meta_uvalue.hpp"
-
-namespace meta_hpp::detail
-{
-    template < typename T >
-    concept any_uvalue_kind             //
-        = 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, uresult>    //
-       || std::is_same_v<T, uvalue>;    //
-}
 
 namespace meta_hpp::detail
 {
     template < typename T, typename Tp = std::decay_t<T> >
-    concept arg_lvalue_ref_kind  //
-        = (!any_uvalue_kind<Tp>) //
+    concept arg_lvalue_ref_kind //
+        = (!uvalue_family<Tp>)  //
        && (std::is_lvalue_reference_v<T>);
 
     template < typename T, typename Tp = std::decay_t<T> >
-    concept arg_rvalue_ref_kind  //
-        = (!any_uvalue_kind<Tp>) //
+    concept arg_rvalue_ref_kind //
+        = (!uvalue_family<Tp>)  //
        && (!std::is_reference_v<T> || std::is_rvalue_reference_v<T>);
 }
 
@@ -44,13 +31,13 @@ namespace meta_hpp::detail
 
     template < typename T, typename Tp = std::decay_t<T> >
     concept inst_class_lvalue_ref_kind    //
-        = (!any_uvalue_kind<Tp>)          //
+        = (!uvalue_family<Tp>)            //
        && (std::is_lvalue_reference_v<T>) //
        && (std::is_class_v<std::remove_pointer_t<std::remove_reference_t<T>>>);
 
     template < typename T, typename Tp = std::decay_t<T> >
     concept inst_class_rvalue_ref_kind                               //
-        = (!any_uvalue_kind<Tp>)                                     //
+        = (!uvalue_family<Tp>)                                       //
        && (!std::is_reference_v<T> || std::is_rvalue_reference_v<T>) //
        && (std::is_class_v<std::remove_pointer_t<std::remove_reference_t<T>>>);
 }
diff --git a/headers/meta.hpp/meta_indices.hpp b/headers/meta.hpp/meta_indices.hpp
index 6b3e292..07b1908 100644
--- a/headers/meta.hpp/meta_indices.hpp
+++ b/headers/meta.hpp/meta_indices.hpp
@@ -9,8 +9,6 @@
 #include "meta_base.hpp"
 #include "meta_types.hpp"
 
-#include "meta_detail/index_family.hpp"
-
 namespace meta_hpp
 {
     class argument_index final {
diff --git a/headers/meta.hpp/meta_uresult.hpp b/headers/meta.hpp/meta_uresult.hpp
index eb7a7cc..393f2f7 100644
--- a/headers/meta.hpp/meta_uresult.hpp
+++ b/headers/meta.hpp/meta_uresult.hpp
@@ -83,9 +83,7 @@ namespace meta_hpp
             typename T,                            //
             typename Tp = std::decay_t<T>,         //
             typename = std::enable_if_t<           //
-                !std::is_same_v<Tp, uerror> &&     //
-                !std::is_same_v<Tp, uvalue> &&     //
-                !std::is_same_v<Tp, uresult> &&    //
+                !detail::uvalue_family<Tp> &&      //
                 !detail::is_in_place_type_v<Tp> && //
                 std::is_copy_constructible_v<Tp>>> //
         uresult(T&& val);
@@ -94,9 +92,7 @@ namespace meta_hpp
             typename T,                            //
             typename Tp = std::decay_t<T>,         //
             typename = std::enable_if_t<           //
-                !std::is_same_v<Tp, uerror> &&     //
-                !std::is_same_v<Tp, uvalue> &&     //
-                !std::is_same_v<Tp, uresult> &&    //
+                !detail::uvalue_family<Tp> &&      //
                 std::is_copy_constructible_v<Tp>>> //
         uresult& operator=(T&& val);
 
diff --git a/headers/meta.hpp/meta_uvalue.hpp b/headers/meta.hpp/meta_uvalue.hpp
index 5479e02..f0fe0a0 100644
--- a/headers/meta.hpp/meta_uvalue.hpp
+++ b/headers/meta.hpp/meta_uvalue.hpp
@@ -26,7 +26,7 @@ namespace meta_hpp
             typename T,                            //
             typename Tp = std::decay_t<T>,         //
             typename = std::enable_if_t<           //
-                !std::is_same_v<Tp, uvalue> &&     //
+                !detail::uvalue_family<Tp> &&      //
                 !detail::is_in_place_type_v<Tp> && //
                 std::is_copy_constructible_v<Tp>>> //
         uvalue(T&& val);
@@ -35,7 +35,7 @@ namespace meta_hpp
             typename T,                            //
             typename Tp = std::decay_t<T>,         //
             typename = std::enable_if_t<           //
-                !std::is_same_v<Tp, uvalue> &&     //
+                !detail::uvalue_family<Tp> &&      //
                 std::is_copy_constructible_v<Tp>>> //
         uvalue& operator=(T&& val);