Rename "aggregate_initialize" to "no_narrowing"

yaito3014 · yaito3014 · commit 1380b7e5def1 · 2026-03-13T16:02:23.000+09:00
diff --git a/include/iris/rvariant/rvariant.hpp b/include/iris/rvariant/rvariant.hpp
@@ -620,10 +620,10 @@ class rvariant : private detail::rvariant_base_t<Ts...>
             (!std::is_same_v<std::remove_cvref_t<T>, rvariant>) &&
             (!is_ttp_specialization_of_v<std::remove_cvref_t<T>, std::in_place_type_t>) &&
             (!is_ctp_specialization_of_v<std::remove_cvref_t<T>, std::in_place_index_t>) &&
-            std::is_constructible_v<typename aggregate_initialize_resolution<T, Ts...>::type, T>
+            std::is_constructible_v<typename no_narrowing_resolution<T, Ts...>::type, T>
     constexpr /* not explicit */ rvariant(T&& t)
-        noexcept(std::is_nothrow_constructible_v<typename aggregate_initialize_resolution<T, Ts...>::type, T>)
-        : base_type(std::in_place_index<aggregate_initialize_resolution<T, Ts...>::index>, std::forward<T>(t))
+        noexcept(std::is_nothrow_constructible_v<typename no_narrowing_resolution<T, Ts...>::type, T>)
+        : base_type(std::in_place_index<no_narrowing_resolution<T, Ts...>::index>, std::forward<T>(t))
     {}
 
 IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
@@ -632,12 +632,12 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
     template<class T>
         requires
             (!std::is_same_v<std::remove_cvref_t<T>, rvariant>) &&
-            detail::variant_assignable<typename aggregate_initialize_resolution<T, Ts...>::type, T>::value
+            detail::variant_assignable<typename no_narrowing_resolution<T, Ts...>::type, T>::value
     constexpr rvariant& operator=(T&& t)
-        noexcept(detail::variant_nothrow_assignable<typename aggregate_initialize_resolution<T, Ts...>::type, T>::value)
+        noexcept(detail::variant_nothrow_assignable<typename no_narrowing_resolution<T, Ts...>::type, T>::value)
     {
-        using Tj = aggregate_initialize_resolution<T, Ts...>::type; // either plain type or wrapped with recursive_wrapper
-        constexpr std::size_t j = aggregate_initialize_resolution<T, Ts...>::index;
+        using Tj = no_narrowing_resolution<T, Ts...>::type; // either plain type or wrapped with recursive_wrapper
+        constexpr std::size_t j = no_narrowing_resolution<T, Ts...>::index;
         static_assert(j != std::variant_npos);
 
         this->raw_visit([this, &t]<std::size_t i, class Ti>(std::in_place_index_t<i>, [[maybe_unused]] Ti& ti)
diff --git a/include/iris/type_traits.hpp b/include/iris/type_traits.hpp
@@ -272,37 +272,38 @@ struct aggregate_initialize_tag
 };
 
 template<std::size_t I, class Ti>
-struct aggregate_initialize_overload
+struct no_narrowing_overload
 {
     template<class T>
-    auto operator()(Ti, T&&) -> aggregate_initialize_tag<I, Ti>
+    auto operator()(T&&) -> aggregate_initialize_tag<I, Ti>
         requires is_convertible_without_narrowing_v<T, Ti>
     {
         return {}; // silence MSVC warning
     }
 };
 
 template<class Is, class... Ts>
-struct aggregate_initialize_fun;
+struct no_narrowing_fun;
 
 // Imaginary function FUN of https://eel.is/c++draft/variant#ctor-14
 template<std::size_t... Is, class... Ts>
-struct aggregate_initialize_fun<std::index_sequence<Is...>, Ts...>
-    : aggregate_initialize_overload<Is, Ts>...
+struct no_narrowing_fun<std::index_sequence<Is...>, Ts...>
+    : no_narrowing_overload<Is, Ts>...
 {
-    using aggregate_initialize_overload<Is, Ts>::operator()...;
+    using no_narrowing_overload<Is, Ts>::operator()...;
 };
 
 template<class... Ts>
-using aggregate_initialize_fun_for = aggregate_initialize_fun<std::index_sequence_for<Ts...>, Ts...>;
+using aggregate_initialize_fun_for = no_narrowing_fun<std::index_sequence_for<Ts...>, Ts...>;
 
 template<class Enabled, class T, class... Ts>
-struct aggregate_initialize_resolution {};
+struct no_narrowing_resolution {};
 
 template<class T, class... Ts>
-struct aggregate_initialize_resolution<
+struct no_narrowing_resolution<
     std::void_t<decltype(aggregate_initialize_fun_for<Ts...>{}(std::declval<T>(), std::declval<T>()))>, T, Ts...
-> {
+>
+{
     using tag = decltype(aggregate_initialize_fun_for<Ts...>{}(std::declval<T>(), std::declval<T>()));
     using type = tag::type;
     static constexpr std::size_t index = tag::index;
@@ -314,7 +315,7 @@ struct aggregate_initialize_resolution<
 // because they would lead to unnecessarily nested instantiation for
 // legitimate infinite recursion errors on recursive types.
 template<class T, class... Ts>
-struct aggregate_initialize_resolution : detail::aggregate_initialize_resolution<void, T, Ts...> {};
+struct no_narrowing_resolution : detail::no_narrowing_resolution<void, T, Ts...> {};
 
 } // iris
 
