@@ -126,8 +126,8 @@ class basic_any: private internal::basic_any_storage<Len, Align> {
         }
     }
 
-    template<typename Type, typename... Args>
-    decltype(auto) initialize([[maybe_unused]] Args &&...args) {
+    template<typename Type>
+    decltype(auto) initialize([[maybe_unused]] auto &&...args) {
         using plain_type = stl::remove_cvref_t<Type>;
 
         vtable = basic_vtable<plain_type>;
@@ -141,7 +141,7 @@ class basic_any: private internal::basic_any_storage<Len, Align> {
             deleter = nullptr;
             using non_reference_type = stl::remove_reference_t<Type>;
             mode = stl::is_const_v<non_reference_type> ? any_policy::cref : any_policy::ref;
-            static_assert((stl::is_lvalue_reference_v<Args> && ...) && (sizeof...(Args) == 1u), "Invalid arguments");
+            static_assert((stl::is_lvalue_reference_v<decltype(args)> && ...) && (sizeof...(args) == 1u), "Invalid arguments");
             // NOLINTNEXTLINE(bugprone-multi-level-implicit-pointer-conversion)
             this->instance = (stl::addressof(args), ...);
             return *static_cast<non_reference_type *>(const_cast<constness_as_t<void, non_reference_type> *>(this->instance));
@@ -154,23 +154,23 @@ class basic_any: private internal::basic_any_storage<Len, Align> {
 
             mode = any_policy::embedded;
 
-            if constexpr(stl::is_aggregate_v<plain_type> && (sizeof...(Args) != 0u || !stl::is_default_constructible_v<plain_type>)) {
-                return *::new(&this->buffer) plain_type{stl::forward<Args>(args)...};
+            if constexpr(stl::is_aggregate_v<plain_type> && (sizeof...(args) != 0u || !stl::is_default_constructible_v<plain_type>)) {
+                return *::new(&this->buffer) plain_type{stl::forward<decltype(args)>(args)...};
             } else {
                 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
-                return *::new(&this->buffer) plain_type(stl::forward<Args>(args)...);
+                return *::new(&this->buffer) plain_type(stl::forward<decltype(args)>(args)...);
             }
         } else {
             deleter = &basic_deleter<plain_type>;
             mode = any_policy::dynamic;
 
-            if constexpr(stl::is_aggregate_v<plain_type> && (sizeof...(Args) != 0u || !stl::is_default_constructible_v<plain_type>)) {
-                this->instance = new plain_type{stl::forward<Args>(args)...};
+            if constexpr(stl::is_aggregate_v<plain_type> && (sizeof...(args) != 0u || !stl::is_default_constructible_v<plain_type>)) {
+                this->instance = new plain_type{stl::forward<decltype(args)>(args)...};
             } else if constexpr(stl::is_array_v<plain_type>) {
-                static_assert(sizeof...(Args) == 0u, "Invalid arguments");
+                static_assert(sizeof...(args) == 0u, "Invalid arguments");
                 this->instance = new plain_type[stl::extent_v<plain_type>]();
             } else {
-                this->instance = new plain_type(stl::forward<Args>(args)...);
+                this->instance = new plain_type(stl::forward<decltype(args)>(args)...);
             }
 
             return *static_cast<plain_type *>(const_cast<void *>(this->instance));
@@ -196,13 +196,12 @@ class basic_any: private internal::basic_any_storage<Len, Align> {
     /**
      * @brief Constructs a wrapper by directly initializing the new object.
      * @tparam Type Type of object to use to initialize the wrapper.
-     * @tparam Args Types of arguments to use to construct the new instance.
      * @param args Parameters to use to construct the instance.
      */
-    template<typename Type, typename... Args>
-    explicit basic_any(stl::in_place_type_t<Type>, Args &&...args)
+    template<typename Type>
+    explicit basic_any(stl::in_place_type_t<Type>, auto &&...args)
         : base_type{} {
-        initialize<Type>(stl::forward<Args>(args)...);
+        initialize<Type>(stl::forward<decltype(args)>(args)...);
     }
 
     /**
@@ -423,14 +422,13 @@ class basic_any: private internal::basic_any_storage<Len, Align> {
     /**
      * @brief Replaces the contained object by creating a new instance directly.
      * @tparam Type Type of object to use to initialize the wrapper.
-     * @tparam Args Types of arguments to use to construct the new instance.
      * @param args Parameters to use to construct the instance.
      * @return A reference to the newly created object, if any.
      */
-    template<typename Type, typename... Args>
-    decltype(auto) emplace(Args &&...args) {
+    template<typename Type>
+    decltype(auto) emplace(auto &&...args) {
         invoke_deleter_if_exists();
-        return initialize<Type>(stl::forward<Args>(args)...);
+        return initialize<Type>(stl::forward<decltype(args)>(args)...);
     }
 
     /**
@@ -589,13 +587,12 @@ template<typename Type, stl::size_t Len, stl::size_t Align>
  * @tparam Type Type of object to use to initialize the wrapper.
  * @tparam Len Size of the buffer reserved for the small buffer optimization.
  * @tparam Align Optional alignment requirement.
- * @tparam Args Types of arguments to use to construct the new instance.
  * @param args Parameters to use to construct the instance.
  * @return A properly initialized wrapper for an object of the given type.
  */
-template<typename Type, stl::size_t Len = basic_any<>::length, stl::size_t Align = basic_any<Len>::alignment, typename... Args>
-[[nodiscard]] basic_any<Len, Align> make_any(Args &&...args) {
-    return basic_any<Len, Align>{stl::in_place_type<Type>, stl::forward<Args>(args)...};
+template<typename Type, stl::size_t Len = basic_any<>::length, stl::size_t Align = basic_any<Len>::alignment>
+[[nodiscard]] basic_any<Len, Align> make_any(auto &&...args) {
+    return basic_any<Len, Align>{stl::in_place_type<Type>, stl::forward<decltype(args)>(args)...};
 }
 
 /**