diff --git a/develop/singles/headers/meta.hpp/meta_all.hpp b/develop/singles/headers/meta.hpp/meta_all.hpp
index 6c77f83..4850124 100644
--- a/develop/singles/headers/meta.hpp/meta_all.hpp
+++ b/develop/singles/headers/meta.hpp/meta_all.hpp
@@ -5311,6 +5311,11 @@ namespace meta_hpp::detail
         }
 
         template < typename To >
+            requires(std::is_pointer_v<To>)
+        [[nodiscard]] bool can_cast_to() const noexcept;
+
+        template < typename To >
+            requires(!std::is_pointer_v<To>)
         [[nodiscard]] bool can_cast_to() const noexcept;
 
     private:
@@ -5346,6 +5351,11 @@ namespace meta_hpp::detail
         , data_{const_cast<std::remove_cvref_t<T>*>(std::addressof(v))} {}
 
         template < typename To >
+            requires(std::is_pointer_v<To>)
+        [[nodiscard]] To cast() const;
+
+        template < typename To >
+            requires(!std::is_pointer_v<To>)
         [[nodiscard]] To cast() const;
 
     private:
@@ -5356,8 +5366,63 @@ namespace meta_hpp::detail
 namespace meta_hpp::detail
 {
     template < typename To >
-    // NOLINTNEXTLINE(*-cognitive-complexity)
-    bool uarg_base::can_cast_to() const noexcept {
+        requires(std::is_pointer_v<To>)
+    [[nodiscard]] bool uarg_base::can_cast_to() const noexcept {
+        using to_raw_type_cv = std::remove_reference_t<To>;
+        using to_raw_type = std::remove_cv_t<to_raw_type_cv>;
+
+        const any_type& from_type = get_raw_type();
+        const any_type& to_type = resolve_type<to_raw_type>();
+
+        const auto is_a = [](const any_type& base, const any_type& derived) {
+            return (base == derived) //
+                || (base.is_class() && derived.is_class() && base.as_class().is_base_of(derived.as_class()));
+        };
+
+        if ( from_type.is_nullptr() && to_type.is_pointer() ) {
+            return true;
+        }
+
+        if ( to_type.is_pointer() && from_type.is_array() ) {
+            const pointer_type& to_type_ptr = to_type.as_pointer();
+            const bool to_type_ptr_readonly = to_type_ptr.get_flags().has(pointer_flags::is_readonly);
+
+            const array_type& from_type_array = from_type.as_array();
+            const bool from_type_array_readonly = is_ref_const();
+
+            const any_type& to_data_type = to_type_ptr.get_data_type();
+            const any_type& from_data_type = from_type_array.get_data_type();
+
+            if ( to_type_ptr_readonly >= from_type_array_readonly ) {
+                if ( to_data_type.is_void() || is_a(to_data_type, from_data_type) ) {
+                    return true;
+                }
+            }
+        }
+
+        if ( to_type.is_pointer() && from_type.is_pointer() ) {
+            const pointer_type& to_type_ptr = to_type.as_pointer();
+            const bool to_type_ptr_readonly = to_type_ptr.get_flags().has(pointer_flags::is_readonly);
+
+            const pointer_type& from_type_ptr = from_type.as_pointer();
+            const bool from_type_ptr_readonly = from_type_ptr.get_flags().has(pointer_flags::is_readonly);
+
+            const any_type& to_data_type = to_type_ptr.get_data_type();
+            const any_type& from_data_type = from_type_ptr.get_data_type();
+
+            if ( to_type_ptr_readonly >= from_type_ptr_readonly ) {
+                if ( to_data_type.is_void() || is_a(to_data_type, from_data_type) ) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    template < typename To >
+        requires(!std::is_pointer_v<To>)
+    [[nodiscard]] bool uarg_base::can_cast_to() const noexcept {
         using to_raw_type_cv = std::remove_reference_t<To>;
         using to_raw_type = std::remove_cv_t<to_raw_type_cv>;
 
@@ -5374,82 +5439,42 @@ namespace meta_hpp::detail
                 || (base.is_class() && derived.is_class() && base.as_class().is_base_of(derived.as_class()));
         };
 
-        if constexpr ( std::is_pointer_v<To> ) {
-            if ( to_type.is_pointer() && from_type.is_nullptr() ) {
-                return true;
+        const auto is_convertible_to_ref = [this]<typename ToRef>(type_list<ToRef>) {
+            switch ( get_ref_type() ) {
+            case ref_types::lvalue:
+                return std::is_convertible_v<noncopyable&, copy_cvref_t<ToRef, noncopyable>>;
+            case ref_types::const_lvalue:
+                return std::is_convertible_v<const noncopyable&, copy_cvref_t<ToRef, noncopyable>>;
+            case ref_types::rvalue:
+                return std::is_convertible_v<noncopyable&&, copy_cvref_t<ToRef, noncopyable>>;
+            case ref_types::const_rvalue:
+                return std::is_convertible_v<const noncopyable&&, copy_cvref_t<ToRef, noncopyable>>;
             }
+            return false;
+        };
 
-            if ( to_type.is_pointer() && from_type.is_array() ) {
-                const pointer_type& to_type_ptr = to_type.as_pointer();
-                const bool to_type_ptr_readonly = to_type_ptr.get_flags().has(pointer_flags::is_readonly);
-
-                const array_type& from_type_array = from_type.as_array();
-                const bool from_type_array_readonly = is_ref_const();
-
-                const any_type& to_data_type = to_type_ptr.get_data_type();
-                const any_type& from_data_type = from_type_array.get_data_type();
-
-                if ( to_type_ptr_readonly >= from_type_array_readonly ) {
-                    if ( to_data_type.is_void() || is_a(to_data_type, from_data_type) ) {
-                        return true;
-                    }
-                }
+        const auto is_constructible_from_type = [this, &is_convertible_to_ref]<typename FromType>(type_list<FromType>) {
+            switch ( get_ref_type() ) {
+            case ref_types::lvalue:
+                return std::is_constructible_v<To, FromType&> && is_convertible_to_ref(type_list<FromType&>{});
+            case ref_types::const_lvalue:
+                return std::is_constructible_v<To, const FromType&> && is_convertible_to_ref(type_list<const FromType&>{});
+            case ref_types::rvalue:
+                return std::is_constructible_v<To, FromType&&> && is_convertible_to_ref(type_list<FromType&&>{});
+            case ref_types::const_rvalue:
+                return std::is_constructible_v<To, const FromType&&> && is_convertible_to_ref(type_list<const FromType&&>{});
             }
-
-            if ( to_type.is_pointer() && from_type.is_pointer() ) {
-                const pointer_type& to_type_ptr = to_type.as_pointer();
-                const bool to_type_ptr_readonly = to_type_ptr.get_flags().has(pointer_flags::is_readonly);
-
-                const pointer_type& from_type_ptr = from_type.as_pointer();
-                const bool from_type_ptr_readonly = from_type_ptr.get_flags().has(pointer_flags::is_readonly);
-
-                const any_type& to_data_type = to_type_ptr.get_data_type();
-                const any_type& from_data_type = from_type_ptr.get_data_type();
-
-                if ( to_type_ptr_readonly >= from_type_ptr_readonly ) {
-                    if ( to_data_type.is_void() || is_a(to_data_type, from_data_type) ) {
-                        return true;
-                    }
-                }
-            }
-        }
+            return false;
+        };
 
         if constexpr ( std::is_reference_v<To> ) {
-            const auto is_convertible = [this]() {
-                switch ( get_ref_type() ) {
-                case ref_types::lvalue:
-                    return std::is_convertible_v<noncopyable&, copy_cvref_t<To, noncopyable>>;
-                case ref_types::const_lvalue:
-                    return std::is_convertible_v<const noncopyable&, copy_cvref_t<To, noncopyable>>;
-                case ref_types::rvalue:
-                    return std::is_convertible_v<noncopyable&&, copy_cvref_t<To, noncopyable>>;
-                case ref_types::const_rvalue:
-                    return std::is_convertible_v<const noncopyable&&, copy_cvref_t<To, noncopyable>>;
-                }
-                return false;
-            };
-
-            if ( is_a(to_type, from_type) && is_convertible() ) {
+            if ( is_a(to_type, from_type) && is_convertible_to_ref(type_list<To>{}) ) {
                 return true;
             }
         }
 
         if constexpr ( !std::is_pointer_v<To> && !std::is_reference_v<To> ) {
-            const auto is_constructible = [this]() {
-                switch ( get_ref_type() ) {
-                case ref_types::lvalue:
-                    return std::is_constructible_v<To, to_raw_type&> && can_cast_to<to_raw_type&>();
-                case ref_types::const_lvalue:
-                    return std::is_constructible_v<To, const to_raw_type&> && can_cast_to<const to_raw_type&>();
-                case ref_types::rvalue:
-                    return std::is_constructible_v<To, to_raw_type&&> && can_cast_to<to_raw_type&&>();
-                case ref_types::const_rvalue:
-                    return std::is_constructible_v<To, const to_raw_type&&> && can_cast_to<const to_raw_type&&>();
-                }
-                return false;
-            };
-
-            if ( is_a(to_type, from_type) && is_constructible() ) {
+            if ( is_a(to_type, from_type) && is_constructible_from_type(type_list<to_raw_type>{}) ) {
                 return true;
             }
         }
@@ -5461,8 +5486,8 @@ namespace meta_hpp::detail
 namespace meta_hpp::detail
 {
     template < typename To >
-    // NOLINTNEXTLINE(*-cognitive-complexity)
-    To uarg::cast() const {
+        requires(std::is_pointer_v<To>)
+    [[nodiscard]] To uarg::cast() const {
         META_HPP_ASSERT(can_cast_to<To>() && "bad argument cast");
 
         using to_raw_type_cv = std::remove_reference_t<To>;
@@ -5471,104 +5496,105 @@ namespace meta_hpp::detail
         const any_type& from_type = get_raw_type();
         const any_type& to_type = resolve_type<to_raw_type>();
 
-        if constexpr ( std::is_pointer_v<To> ) {
-            if ( to_type.is_pointer() && from_type.is_nullptr() ) {
-                return static_cast<to_raw_type_cv>(nullptr);
+        if ( to_type.is_pointer() && from_type.is_nullptr() ) {
+            return static_cast<to_raw_type_cv>(nullptr);
+        }
+
+        if ( to_type.is_pointer() && from_type.is_array() ) {
+            const pointer_type& to_type_ptr = to_type.as_pointer();
+            const array_type& from_type_array = from_type.as_array();
+
+            const any_type& to_data_type = to_type_ptr.get_data_type();
+            const any_type& from_data_type = from_type_array.get_data_type();
+
+            if ( to_data_type.is_void() || to_data_type == from_data_type ) {
+                return static_cast<to_raw_type_cv>(data_);
             }
 
-            if ( to_type.is_pointer() && from_type.is_array() ) {
-                const pointer_type& to_type_ptr = to_type.as_pointer();
-                const array_type& from_type_array = from_type.as_array();
+            if ( to_data_type.is_class() && from_data_type.is_class() ) {
+                const class_type& to_data_class = to_data_type.as_class();
+                const class_type& from_data_class = from_data_type.as_class();
 
-                const any_type& to_data_type = to_type_ptr.get_data_type();
-                const any_type& from_data_type = from_type_array.get_data_type();
-
-                if ( to_data_type.is_void() || to_data_type == from_data_type ) {
-                    return static_cast<to_raw_type_cv>(data_);
-                }
-
-                if ( to_data_type.is_class() && from_data_type.is_class() ) {
-                    const class_type& to_data_class = to_data_type.as_class();
-                    const class_type& from_data_class = from_data_type.as_class();
-
-                    void* to_ptr = pointer_upcast(data_, from_data_class, to_data_class);
-                    return static_cast<to_raw_type_cv>(to_ptr);
-                }
-            }
-
-            if ( to_type.is_pointer() && from_type.is_pointer() ) {
-                const pointer_type& to_type_ptr = to_type.as_pointer();
-                const pointer_type& from_type_ptr = from_type.as_pointer();
-
-                const any_type& to_data_type = to_type_ptr.get_data_type();
-                const any_type& from_data_type = from_type_ptr.get_data_type();
-
-                void** from_data_ptr = static_cast<void**>(data_);
-
-                if ( to_data_type.is_void() || to_data_type == from_data_type ) {
-                    return static_cast<to_raw_type_cv>(*from_data_ptr);
-                }
-
-                if ( to_data_type.is_class() && from_data_type.is_class() ) {
-                    const class_type& to_data_class = to_data_type.as_class();
-                    const class_type& from_data_class = from_data_type.as_class();
-
-                    void* to_ptr = pointer_upcast(*from_data_ptr, from_data_class, to_data_class);
-                    return static_cast<to_raw_type_cv>(to_ptr);
-                }
+                void* to_ptr = pointer_upcast(data_, from_data_class, to_data_class);
+                return static_cast<to_raw_type_cv>(to_ptr);
             }
         }
 
-        if constexpr ( std::is_reference_v<To> ) {
-            if ( to_type == from_type ) {
-                if constexpr ( std::is_lvalue_reference_v<To> ) {
-                    return *static_cast<to_raw_type_cv*>(data_);
-                }
+        if ( to_type.is_pointer() && from_type.is_pointer() ) {
+            const pointer_type& to_type_ptr = to_type.as_pointer();
+            const pointer_type& from_type_ptr = from_type.as_pointer();
 
-                if constexpr ( std::is_rvalue_reference_v<To> ) {
-                    return std::move(*static_cast<to_raw_type_cv*>(data_));
-                }
+            const any_type& to_data_type = to_type_ptr.get_data_type();
+            const any_type& from_data_type = from_type_ptr.get_data_type();
+
+            void** from_data_ptr = static_cast<void**>(data_);
+
+            if ( to_data_type.is_void() || to_data_type == from_data_type ) {
+                return static_cast<to_raw_type_cv>(*from_data_ptr);
             }
 
-            if ( to_type.is_class() && from_type.is_class() ) {
-                const class_type& to_class = to_type.as_class();
-                const class_type& from_class = from_type.as_class();
+            if ( to_data_type.is_class() && from_data_type.is_class() ) {
+                const class_type& to_data_class = to_data_type.as_class();
+                const class_type& from_data_class = from_data_type.as_class();
 
-                void* to_ptr = pointer_upcast(data_, from_class, to_class);
-
-                if constexpr ( std::is_lvalue_reference_v<To> ) {
-                    return *static_cast<to_raw_type_cv*>(to_ptr);
-                }
-
-                if constexpr ( std::is_rvalue_reference_v<To> ) {
-                    return std::move(*static_cast<to_raw_type_cv*>(to_ptr));
-                }
+                void* to_ptr = pointer_upcast(*from_data_ptr, from_data_class, to_data_class);
+                return static_cast<to_raw_type_cv>(to_ptr);
             }
         }
 
-        if constexpr ( !std::is_pointer_v<To> && !std::is_reference_v<To> ) {
-            if constexpr ( std::is_constructible_v<To, to_raw_type&> ) {
-                if ( get_ref_type() == ref_types::lvalue ) {
-                    return To{cast<to_raw_type&>()};
-                }
-            }
+        META_HPP_THROW("bad argument cast");
+    }
 
-            if constexpr ( std::is_constructible_v<To, const to_raw_type&> ) {
-                if ( get_ref_type() == ref_types::const_lvalue ) {
-                    return To{cast<const to_raw_type&>()};
-                }
-            }
+    template < typename To >
+        requires(!std::is_pointer_v<To>)
+    [[nodiscard]] To uarg::cast() const {
+        META_HPP_ASSERT(can_cast_to<To>() && "bad argument cast");
 
-            if constexpr ( std::is_constructible_v<To, to_raw_type&&> ) {
-                if ( get_ref_type() == ref_types::rvalue ) {
-                    return To{cast<to_raw_type&&>()};
-                }
-            }
+        using to_raw_type_cv = std::remove_reference_t<To>;
+        using to_raw_type = std::remove_cv_t<to_raw_type_cv>;
 
-            if constexpr ( std::is_constructible_v<To, const to_raw_type&&> ) {
-                if ( get_ref_type() == ref_types::const_rvalue ) {
-                    return To{cast<const to_raw_type&&>()};
+        static_assert( //
+            !(std::is_reference_v<To> && std::is_pointer_v<to_raw_type>),
+            "references to pointers are not supported yet"
+        );
+
+        const any_type& from_type = get_raw_type();
+        const any_type& to_type = resolve_type<to_raw_type>();
+
+        void* to_ptr = to_type == from_type //
+                         ? data_
+                         : pointer_upcast(data_, from_type.as_class(), to_type.as_class());
+
+        if constexpr ( std::is_lvalue_reference_v<To> ) {
+            return *static_cast<to_raw_type_cv*>(to_ptr);
+        }
+
+        if constexpr ( std::is_rvalue_reference_v<To> ) {
+            return std::move(*static_cast<to_raw_type_cv*>(to_ptr));
+        }
+
+        if constexpr ( !std::is_reference_v<To> ) {
+            switch ( get_ref_type() ) {
+            case ref_types::lvalue:
+                if constexpr ( std::is_constructible_v<To, to_raw_type&> ) {
+                    return To{*static_cast<to_raw_type*>(to_ptr)};
                 }
+                break;
+            case ref_types::const_lvalue:
+                if constexpr ( std::is_constructible_v<To, const to_raw_type&> ) {
+                    return To{*static_cast<const to_raw_type*>(to_ptr)};
+                }
+                break;
+            case ref_types::rvalue:
+                if constexpr ( std::is_constructible_v<To, to_raw_type&&> ) {
+                    return To{std::move(*static_cast<to_raw_type*>(to_ptr))};
+                }
+                break;
+            case ref_types::const_rvalue:
+                if constexpr ( std::is_constructible_v<To, const to_raw_type&&> ) {
+                    return To{std::move(*static_cast<const to_raw_type*>(to_ptr))};
+                }
+                break;
             }
         }
 
diff --git a/headers/meta.hpp/meta_detail/value_utilities/uarg.hpp b/headers/meta.hpp/meta_detail/value_utilities/uarg.hpp
index b96fd6b..3818691 100644
--- a/headers/meta.hpp/meta_detail/value_utilities/uarg.hpp
+++ b/headers/meta.hpp/meta_detail/value_utilities/uarg.hpp
@@ -82,6 +82,11 @@ namespace meta_hpp::detail
         }
 
         template < typename To >
+            requires(std::is_pointer_v<To>)
+        [[nodiscard]] bool can_cast_to() const noexcept;
+
+        template < typename To >
+            requires(!std::is_pointer_v<To>)
         [[nodiscard]] bool can_cast_to() const noexcept;
 
     private:
@@ -117,6 +122,11 @@ namespace meta_hpp::detail
         , data_{const_cast<std::remove_cvref_t<T>*>(std::addressof(v))} {}
 
         template < typename To >
+            requires(std::is_pointer_v<To>)
+        [[nodiscard]] To cast() const;
+
+        template < typename To >
+            requires(!std::is_pointer_v<To>)
         [[nodiscard]] To cast() const;
 
     private:
@@ -127,8 +137,63 @@ namespace meta_hpp::detail
 namespace meta_hpp::detail
 {
     template < typename To >
-    // NOLINTNEXTLINE(*-cognitive-complexity)
-    bool uarg_base::can_cast_to() const noexcept {
+        requires(std::is_pointer_v<To>)
+    [[nodiscard]] bool uarg_base::can_cast_to() const noexcept {
+        using to_raw_type_cv = std::remove_reference_t<To>;
+        using to_raw_type = std::remove_cv_t<to_raw_type_cv>;
+
+        const any_type& from_type = get_raw_type();
+        const any_type& to_type = resolve_type<to_raw_type>();
+
+        const auto is_a = [](const any_type& base, const any_type& derived) {
+            return (base == derived) //
+                || (base.is_class() && derived.is_class() && base.as_class().is_base_of(derived.as_class()));
+        };
+
+        if ( from_type.is_nullptr() && to_type.is_pointer() ) {
+            return true;
+        }
+
+        if ( to_type.is_pointer() && from_type.is_array() ) {
+            const pointer_type& to_type_ptr = to_type.as_pointer();
+            const bool to_type_ptr_readonly = to_type_ptr.get_flags().has(pointer_flags::is_readonly);
+
+            const array_type& from_type_array = from_type.as_array();
+            const bool from_type_array_readonly = is_ref_const();
+
+            const any_type& to_data_type = to_type_ptr.get_data_type();
+            const any_type& from_data_type = from_type_array.get_data_type();
+
+            if ( to_type_ptr_readonly >= from_type_array_readonly ) {
+                if ( to_data_type.is_void() || is_a(to_data_type, from_data_type) ) {
+                    return true;
+                }
+            }
+        }
+
+        if ( to_type.is_pointer() && from_type.is_pointer() ) {
+            const pointer_type& to_type_ptr = to_type.as_pointer();
+            const bool to_type_ptr_readonly = to_type_ptr.get_flags().has(pointer_flags::is_readonly);
+
+            const pointer_type& from_type_ptr = from_type.as_pointer();
+            const bool from_type_ptr_readonly = from_type_ptr.get_flags().has(pointer_flags::is_readonly);
+
+            const any_type& to_data_type = to_type_ptr.get_data_type();
+            const any_type& from_data_type = from_type_ptr.get_data_type();
+
+            if ( to_type_ptr_readonly >= from_type_ptr_readonly ) {
+                if ( to_data_type.is_void() || is_a(to_data_type, from_data_type) ) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    template < typename To >
+        requires(!std::is_pointer_v<To>)
+    [[nodiscard]] bool uarg_base::can_cast_to() const noexcept {
         using to_raw_type_cv = std::remove_reference_t<To>;
         using to_raw_type = std::remove_cv_t<to_raw_type_cv>;
 
@@ -145,82 +210,42 @@ namespace meta_hpp::detail
                 || (base.is_class() && derived.is_class() && base.as_class().is_base_of(derived.as_class()));
         };
 
-        if constexpr ( std::is_pointer_v<To> ) {
-            if ( to_type.is_pointer() && from_type.is_nullptr() ) {
-                return true;
+        const auto is_convertible_to_ref = [this]<typename ToRef>(type_list<ToRef>) {
+            switch ( get_ref_type() ) {
+            case ref_types::lvalue:
+                return std::is_convertible_v<noncopyable&, copy_cvref_t<ToRef, noncopyable>>;
+            case ref_types::const_lvalue:
+                return std::is_convertible_v<const noncopyable&, copy_cvref_t<ToRef, noncopyable>>;
+            case ref_types::rvalue:
+                return std::is_convertible_v<noncopyable&&, copy_cvref_t<ToRef, noncopyable>>;
+            case ref_types::const_rvalue:
+                return std::is_convertible_v<const noncopyable&&, copy_cvref_t<ToRef, noncopyable>>;
             }
+            return false;
+        };
 
-            if ( to_type.is_pointer() && from_type.is_array() ) {
-                const pointer_type& to_type_ptr = to_type.as_pointer();
-                const bool to_type_ptr_readonly = to_type_ptr.get_flags().has(pointer_flags::is_readonly);
-
-                const array_type& from_type_array = from_type.as_array();
-                const bool from_type_array_readonly = is_ref_const();
-
-                const any_type& to_data_type = to_type_ptr.get_data_type();
-                const any_type& from_data_type = from_type_array.get_data_type();
-
-                if ( to_type_ptr_readonly >= from_type_array_readonly ) {
-                    if ( to_data_type.is_void() || is_a(to_data_type, from_data_type) ) {
-                        return true;
-                    }
-                }
+        const auto is_constructible_from_type = [this, &is_convertible_to_ref]<typename FromType>(type_list<FromType>) {
+            switch ( get_ref_type() ) {
+            case ref_types::lvalue:
+                return std::is_constructible_v<To, FromType&> && is_convertible_to_ref(type_list<FromType&>{});
+            case ref_types::const_lvalue:
+                return std::is_constructible_v<To, const FromType&> && is_convertible_to_ref(type_list<const FromType&>{});
+            case ref_types::rvalue:
+                return std::is_constructible_v<To, FromType&&> && is_convertible_to_ref(type_list<FromType&&>{});
+            case ref_types::const_rvalue:
+                return std::is_constructible_v<To, const FromType&&> && is_convertible_to_ref(type_list<const FromType&&>{});
             }
-
-            if ( to_type.is_pointer() && from_type.is_pointer() ) {
-                const pointer_type& to_type_ptr = to_type.as_pointer();
-                const bool to_type_ptr_readonly = to_type_ptr.get_flags().has(pointer_flags::is_readonly);
-
-                const pointer_type& from_type_ptr = from_type.as_pointer();
-                const bool from_type_ptr_readonly = from_type_ptr.get_flags().has(pointer_flags::is_readonly);
-
-                const any_type& to_data_type = to_type_ptr.get_data_type();
-                const any_type& from_data_type = from_type_ptr.get_data_type();
-
-                if ( to_type_ptr_readonly >= from_type_ptr_readonly ) {
-                    if ( to_data_type.is_void() || is_a(to_data_type, from_data_type) ) {
-                        return true;
-                    }
-                }
-            }
-        }
+            return false;
+        };
 
         if constexpr ( std::is_reference_v<To> ) {
-            const auto is_convertible = [this]() {
-                switch ( get_ref_type() ) {
-                case ref_types::lvalue:
-                    return std::is_convertible_v<noncopyable&, copy_cvref_t<To, noncopyable>>;
-                case ref_types::const_lvalue:
-                    return std::is_convertible_v<const noncopyable&, copy_cvref_t<To, noncopyable>>;
-                case ref_types::rvalue:
-                    return std::is_convertible_v<noncopyable&&, copy_cvref_t<To, noncopyable>>;
-                case ref_types::const_rvalue:
-                    return std::is_convertible_v<const noncopyable&&, copy_cvref_t<To, noncopyable>>;
-                }
-                return false;
-            };
-
-            if ( is_a(to_type, from_type) && is_convertible() ) {
+            if ( is_a(to_type, from_type) && is_convertible_to_ref(type_list<To>{}) ) {
                 return true;
             }
         }
 
         if constexpr ( !std::is_pointer_v<To> && !std::is_reference_v<To> ) {
-            const auto is_constructible = [this]() {
-                switch ( get_ref_type() ) {
-                case ref_types::lvalue:
-                    return std::is_constructible_v<To, to_raw_type&> && can_cast_to<to_raw_type&>();
-                case ref_types::const_lvalue:
-                    return std::is_constructible_v<To, const to_raw_type&> && can_cast_to<const to_raw_type&>();
-                case ref_types::rvalue:
-                    return std::is_constructible_v<To, to_raw_type&&> && can_cast_to<to_raw_type&&>();
-                case ref_types::const_rvalue:
-                    return std::is_constructible_v<To, const to_raw_type&&> && can_cast_to<const to_raw_type&&>();
-                }
-                return false;
-            };
-
-            if ( is_a(to_type, from_type) && is_constructible() ) {
+            if ( is_a(to_type, from_type) && is_constructible_from_type(type_list<to_raw_type>{}) ) {
                 return true;
             }
         }
@@ -232,8 +257,8 @@ namespace meta_hpp::detail
 namespace meta_hpp::detail
 {
     template < typename To >
-    // NOLINTNEXTLINE(*-cognitive-complexity)
-    To uarg::cast() const {
+        requires(std::is_pointer_v<To>)
+    [[nodiscard]] To uarg::cast() const {
         META_HPP_ASSERT(can_cast_to<To>() && "bad argument cast");
 
         using to_raw_type_cv = std::remove_reference_t<To>;
@@ -242,104 +267,105 @@ namespace meta_hpp::detail
         const any_type& from_type = get_raw_type();
         const any_type& to_type = resolve_type<to_raw_type>();
 
-        if constexpr ( std::is_pointer_v<To> ) {
-            if ( to_type.is_pointer() && from_type.is_nullptr() ) {
-                return static_cast<to_raw_type_cv>(nullptr);
+        if ( to_type.is_pointer() && from_type.is_nullptr() ) {
+            return static_cast<to_raw_type_cv>(nullptr);
+        }
+
+        if ( to_type.is_pointer() && from_type.is_array() ) {
+            const pointer_type& to_type_ptr = to_type.as_pointer();
+            const array_type& from_type_array = from_type.as_array();
+
+            const any_type& to_data_type = to_type_ptr.get_data_type();
+            const any_type& from_data_type = from_type_array.get_data_type();
+
+            if ( to_data_type.is_void() || to_data_type == from_data_type ) {
+                return static_cast<to_raw_type_cv>(data_);
             }
 
-            if ( to_type.is_pointer() && from_type.is_array() ) {
-                const pointer_type& to_type_ptr = to_type.as_pointer();
-                const array_type& from_type_array = from_type.as_array();
+            if ( to_data_type.is_class() && from_data_type.is_class() ) {
+                const class_type& to_data_class = to_data_type.as_class();
+                const class_type& from_data_class = from_data_type.as_class();
 
-                const any_type& to_data_type = to_type_ptr.get_data_type();
-                const any_type& from_data_type = from_type_array.get_data_type();
-
-                if ( to_data_type.is_void() || to_data_type == from_data_type ) {
-                    return static_cast<to_raw_type_cv>(data_);
-                }
-
-                if ( to_data_type.is_class() && from_data_type.is_class() ) {
-                    const class_type& to_data_class = to_data_type.as_class();
-                    const class_type& from_data_class = from_data_type.as_class();
-
-                    void* to_ptr = pointer_upcast(data_, from_data_class, to_data_class);
-                    return static_cast<to_raw_type_cv>(to_ptr);
-                }
-            }
-
-            if ( to_type.is_pointer() && from_type.is_pointer() ) {
-                const pointer_type& to_type_ptr = to_type.as_pointer();
-                const pointer_type& from_type_ptr = from_type.as_pointer();
-
-                const any_type& to_data_type = to_type_ptr.get_data_type();
-                const any_type& from_data_type = from_type_ptr.get_data_type();
-
-                void** from_data_ptr = static_cast<void**>(data_);
-
-                if ( to_data_type.is_void() || to_data_type == from_data_type ) {
-                    return static_cast<to_raw_type_cv>(*from_data_ptr);
-                }
-
-                if ( to_data_type.is_class() && from_data_type.is_class() ) {
-                    const class_type& to_data_class = to_data_type.as_class();
-                    const class_type& from_data_class = from_data_type.as_class();
-
-                    void* to_ptr = pointer_upcast(*from_data_ptr, from_data_class, to_data_class);
-                    return static_cast<to_raw_type_cv>(to_ptr);
-                }
+                void* to_ptr = pointer_upcast(data_, from_data_class, to_data_class);
+                return static_cast<to_raw_type_cv>(to_ptr);
             }
         }
 
-        if constexpr ( std::is_reference_v<To> ) {
-            if ( to_type == from_type ) {
-                if constexpr ( std::is_lvalue_reference_v<To> ) {
-                    return *static_cast<to_raw_type_cv*>(data_);
-                }
+        if ( to_type.is_pointer() && from_type.is_pointer() ) {
+            const pointer_type& to_type_ptr = to_type.as_pointer();
+            const pointer_type& from_type_ptr = from_type.as_pointer();
 
-                if constexpr ( std::is_rvalue_reference_v<To> ) {
-                    return std::move(*static_cast<to_raw_type_cv*>(data_));
-                }
+            const any_type& to_data_type = to_type_ptr.get_data_type();
+            const any_type& from_data_type = from_type_ptr.get_data_type();
+
+            void** from_data_ptr = static_cast<void**>(data_);
+
+            if ( to_data_type.is_void() || to_data_type == from_data_type ) {
+                return static_cast<to_raw_type_cv>(*from_data_ptr);
             }
 
-            if ( to_type.is_class() && from_type.is_class() ) {
-                const class_type& to_class = to_type.as_class();
-                const class_type& from_class = from_type.as_class();
+            if ( to_data_type.is_class() && from_data_type.is_class() ) {
+                const class_type& to_data_class = to_data_type.as_class();
+                const class_type& from_data_class = from_data_type.as_class();
 
-                void* to_ptr = pointer_upcast(data_, from_class, to_class);
-
-                if constexpr ( std::is_lvalue_reference_v<To> ) {
-                    return *static_cast<to_raw_type_cv*>(to_ptr);
-                }
-
-                if constexpr ( std::is_rvalue_reference_v<To> ) {
-                    return std::move(*static_cast<to_raw_type_cv*>(to_ptr));
-                }
+                void* to_ptr = pointer_upcast(*from_data_ptr, from_data_class, to_data_class);
+                return static_cast<to_raw_type_cv>(to_ptr);
             }
         }
 
-        if constexpr ( !std::is_pointer_v<To> && !std::is_reference_v<To> ) {
-            if constexpr ( std::is_constructible_v<To, to_raw_type&> ) {
-                if ( get_ref_type() == ref_types::lvalue ) {
-                    return To{cast<to_raw_type&>()};
-                }
-            }
+        META_HPP_THROW("bad argument cast");
+    }
 
-            if constexpr ( std::is_constructible_v<To, const to_raw_type&> ) {
-                if ( get_ref_type() == ref_types::const_lvalue ) {
-                    return To{cast<const to_raw_type&>()};
-                }
-            }
+    template < typename To >
+        requires(!std::is_pointer_v<To>)
+    [[nodiscard]] To uarg::cast() const {
+        META_HPP_ASSERT(can_cast_to<To>() && "bad argument cast");
 
-            if constexpr ( std::is_constructible_v<To, to_raw_type&&> ) {
-                if ( get_ref_type() == ref_types::rvalue ) {
-                    return To{cast<to_raw_type&&>()};
-                }
-            }
+        using to_raw_type_cv = std::remove_reference_t<To>;
+        using to_raw_type = std::remove_cv_t<to_raw_type_cv>;
 
-            if constexpr ( std::is_constructible_v<To, const to_raw_type&&> ) {
-                if ( get_ref_type() == ref_types::const_rvalue ) {
-                    return To{cast<const to_raw_type&&>()};
+        static_assert( //
+            !(std::is_reference_v<To> && std::is_pointer_v<to_raw_type>),
+            "references to pointers are not supported yet"
+        );
+
+        const any_type& from_type = get_raw_type();
+        const any_type& to_type = resolve_type<to_raw_type>();
+
+        void* to_ptr = to_type == from_type //
+                         ? data_
+                         : pointer_upcast(data_, from_type.as_class(), to_type.as_class());
+
+        if constexpr ( std::is_lvalue_reference_v<To> ) {
+            return *static_cast<to_raw_type_cv*>(to_ptr);
+        }
+
+        if constexpr ( std::is_rvalue_reference_v<To> ) {
+            return std::move(*static_cast<to_raw_type_cv*>(to_ptr));
+        }
+
+        if constexpr ( !std::is_reference_v<To> ) {
+            switch ( get_ref_type() ) {
+            case ref_types::lvalue:
+                if constexpr ( std::is_constructible_v<To, to_raw_type&> ) {
+                    return To{*static_cast<to_raw_type*>(to_ptr)};
                 }
+                break;
+            case ref_types::const_lvalue:
+                if constexpr ( std::is_constructible_v<To, const to_raw_type&> ) {
+                    return To{*static_cast<const to_raw_type*>(to_ptr)};
+                }
+                break;
+            case ref_types::rvalue:
+                if constexpr ( std::is_constructible_v<To, to_raw_type&&> ) {
+                    return To{std::move(*static_cast<to_raw_type*>(to_ptr))};
+                }
+                break;
+            case ref_types::const_rvalue:
+                if constexpr ( std::is_constructible_v<To, const to_raw_type&&> ) {
+                    return To{std::move(*static_cast<const to_raw_type*>(to_ptr))};
+                }
+                break;
             }
         }