minor changes

TODO

@@ -14,7 +14,6 @@
   - each with entity return the shared component multiple times, one per entity that refers to it
   - each components only return actual component, so shared components are returned only once
 * types defined at runtime that refer to the same compile-time type (but to different pools) are possible, the library is almost there
-* add take functionality, eg registry.take(entity, other); where it takes the entity and all its components from registry and move them to other
 * add opaque input iterators to views and groups that return tuples <entity, T &...> (proxy), multi-pass guaranteed
 * add fast lane for raw iterations, extend mt doc to describe allowed add/remove with pre-allocations on fast lanes
 * registry.each<T...>(first, last) by iterators, entities/components guaranteed
@@ -25,3 +24,8 @@
 TODO
 * custom (decoupled) pools ==> double buffering, shared components, multi-model
 * use direct access (pool-like) also for context variables
+* add take functionality, eg registry.take(entity, other); where it takes the entity and all its components from registry and move them to other
+* add merge functionality, eg you have entity with A-B, and "apply" a clone from an entity with B-C. B gets replaced, C gets added, and A stays
+  - cloning all/part of the components are both required and a target entity on which to stomp your stuff could help
+  - clone is just clone, creating new entity. But yeah, both "clone-all", and "clone-components"
+  - for "apply", again both All and Components, and maybe an enum of what kind of apply "dont overwrite, overwrite, add-only"

src/entt/meta/factory.hpp

@@ -742,7 +742,7 @@ public:
     template<auto Func, typename... Property>
     meta_factory func(const ENTT_ID_TYPE identifier, Property &&... property) ENTT_NOEXCEPT {
         using owner_type = std::integral_constant<decltype(Func), Func>;
-        using func_type = internal::meta_function_helper<std::integral_constant<decltype(Func), Func>>;
+        using helper_type = internal::meta_function_helper<std::integral_constant<decltype(Func), Func>>;
         auto * const type = internal::meta_info<Type>::resolve();
 
         static internal::meta_func_node node{
@@ -751,13 +751,13 @@ public:
             type,
             nullptr,
             nullptr,
-            func_type::size,
-            func_type::is_const,
-            func_type::is_static,
-            &internal::meta_info<typename func_type::return_type>::resolve,
-            &func_type::arg,
+            helper_type::size,
+            helper_type::is_const,
+            helper_type::is_static,
+            &internal::meta_info<typename helper_type::return_type>::resolve,
+            &helper_type::arg,
             [](meta_handle handle, meta_any *any) {
-                return internal::invoke<Type, Func>(handle, any, std::make_index_sequence<func_type::size>{});
+                return internal::invoke<Type, Func>(handle, any, std::make_index_sequence<helper_type::size>{});
             },
             []() ENTT_NOEXCEPT -> meta_func {
                 return &node;