Removing export declarations from non-primary templates

libs/core/algorithms/include/hpx/algorithms/traits/is_pair.hpp

@@ -15,6 +15,6 @@ namespace hpx::traits {
     HPX_CXX_CORE_EXPORT template <typename T>
     inline constexpr bool is_pair_v = false;
 
-    HPX_CXX_CORE_EXPORT template <typename T1, typename T2>
+    template <typename T1, typename T2>
     inline constexpr bool is_pair_v<std::pair<T1, T2>> = true;
 }    // namespace hpx::traits

libs/core/algorithms/include/hpx/algorithms/traits/pointer_category.hpp

@@ -41,7 +41,7 @@ namespace hpx::traits {
             using type = std::underlying_type_t<T>;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct unwrap_enum<T, false>
         {
             using type = T;
@@ -69,27 +69,27 @@ namespace hpx::traits {
         };
 
         // every type is layout-compatible with itself
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct pointer_category_helper<T, T>
         {
             using type = std::conditional_t<std::is_trivially_copyable_v<T>,
                 trivially_copyable_pointer_tag, general_pointer_tag>;
         };
 
         // pointers are layout compatible
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct pointer_category_helper<T*, T const*>
         {
             using type = trivially_copyable_pointer_tag;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct pointer_category_helper<T*, T volatile*>
         {
             using type = trivially_copyable_pointer_tag;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct pointer_category_helper<T*, T const volatile*>
         {
             using type = trivially_copyable_pointer_tag;
@@ -116,7 +116,7 @@ namespace hpx::traits {
                 general_pointer_tag>;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Source, typename Dest>
+        template <typename Source, typename Dest>
         struct pointer_move_category<Source, Dest, false>
         {
             using type = general_pointer_tag;
@@ -134,7 +134,7 @@ namespace hpx::traits {
                 general_pointer_tag>;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Source, typename Dest>
+        template <typename Source, typename Dest>
         struct pointer_copy_category<Source, Dest, false>
         {
             using type = general_pointer_tag;
@@ -150,7 +150,7 @@ namespace hpx::traits {
                 relocatable_pointer_tag, general_pointer_tag>;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Source, typename Dest>
+        template <typename Source, typename Dest>
         struct pointer_relocate_category<Source, Dest, false>
         {
             using type = general_pointer_tag;

libs/core/algorithms/include/hpx/algorithms/traits/projected.hpp

@@ -28,7 +28,7 @@ namespace hpx::traits {
 
     // For segmented iterators, we consider the local_raw_iterator instead of
     // the given one.
-    HPX_CXX_CORE_EXPORT template <typename Iterator>
+    template <typename Iterator>
     struct projected_iterator<Iterator,
         std::enable_if_t<is_segmented_iterator_v<Iterator>>>
     {
@@ -39,7 +39,7 @@ namespace hpx::traits {
             local_iterator>::local_raw_iterator;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Iterator>
+    template <typename Iterator>
     struct projected_iterator<Iterator,
         std::void_t<typename std::decay_t<Iterator>::proxy_type>>
     {
@@ -59,7 +59,7 @@ namespace hpx::parallel::traits {
             typename Enable = void>
         struct projected_result_of;
 
-        HPX_CXX_CORE_EXPORT template <typename Proj, typename Iter>
+        template <typename Proj, typename Iter>
         struct projected_result_of<Proj, Iter,
             std::enable_if_t<hpx::traits::is_iterator_v<Iter>>>
           : hpx::util::invoke_result<Proj, hpx::traits::iter_reference_t<Iter>>
@@ -92,7 +92,7 @@ namespace hpx::parallel::traits {
             typename Enable = void>
         struct projected_result_of_vector_pack;
 
-        HPX_CXX_CORE_EXPORT template <typename Projected>
+        template <typename Projected>
         struct projected_result_of_vector_pack<Projected,
             std::void_t<typename Projected::iterator_type>>
           : projected_result_of_vector_pack_<typename Projected::projector_type,
@@ -123,7 +123,7 @@ namespace hpx::parallel::traits {
         // void
 
         // clang-format off
-        HPX_CXX_CORE_EXPORT template <typename Proj, typename Iter>
+        template <typename Proj, typename Iter>
         struct is_projected<Proj, Iter,
             std::enable_if_t<
                 hpx::traits::is_iterator_v<Iter> &&
@@ -142,7 +142,7 @@ namespace hpx::parallel::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Projected>
+        template <typename Projected>
         struct is_projected_indirect<Projected,
             std::void_t<typename Projected::projector_type>>
           : detail::is_projected<typename Projected::projector_type,
@@ -180,7 +180,7 @@ namespace hpx::parallel::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Projected>
+    template <typename Projected>
     struct is_projected_zip_iterator<Projected,
         std::void_t<typename Projected::iterator_type>>
       : hpx::traits::is_zip_iterator<typename Projected::iterator_type>
@@ -201,8 +201,7 @@ namespace hpx::parallel::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F,
-            typename... Projected>
+        template <typename ExPolicy, typename F, typename... Projected>
         struct is_indirect_callable<ExPolicy, F, hpx::util::pack<Projected...>,
             std::enable_if_t<
                 hpx::util::all_of_v<is_projected_indirect<Projected>...> &&
@@ -218,8 +217,7 @@ namespace hpx::parallel::traits {
         // Vector pack execution policies used with zip-iterators require
         // special handling because zip_iterator<>::reference is not a real
         // reference type.
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F,
-            typename... Projected>
+        template <typename ExPolicy, typename F, typename... Projected>
         struct is_indirect_callable<ExPolicy, F, hpx::util::pack<Projected...>,
             std::enable_if_t<
                 hpx::util::all_of_v<is_projected_indirect<Projected>...> &&

libs/core/algorithms/include/hpx/algorithms/traits/projected_range.hpp

@@ -21,7 +21,7 @@ namespace hpx::parallel::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Proj, typename Rng>
+    template <typename Proj, typename Rng>
     struct projected_range_result_of<Proj, Rng,
         std::enable_if_t<std::ranges::range<Rng>>>
       : detail::projected_result_of<std::decay_t<Proj>,
@@ -36,7 +36,7 @@ namespace hpx::parallel::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Proj, typename Rng>
+    template <typename Proj, typename Rng>
     struct is_projected_range<Proj, Rng,
         std::enable_if_t<std::ranges::range<Rng>>>
       : detail::is_projected<std::decay_t<Proj>, std::ranges::iterator_t<Rng>>
@@ -54,7 +54,7 @@ namespace hpx::parallel::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Proj, typename Rng>
+    template <typename Proj, typename Rng>
     struct projected_range<Proj, Rng, std::enable_if_t<std::ranges::range<Rng>>>
     {
         using projector_type = std::decay_t<Proj>;

libs/core/algorithms/include/hpx/parallel/algorithms/copy.hpp

@@ -439,7 +439,7 @@ namespace hpx::parallel {
             typename Enable = void>
         struct copy_iter;
 
-        HPX_CXX_CORE_EXPORT template <typename FwdIter1, typename FwdIter2>
+        template <typename FwdIter1, typename FwdIter2>
         struct copy_iter<FwdIter1, FwdIter2,
             std::enable_if_t<
                 iterators_are_segmented<FwdIter1, FwdIter2>::value>>
@@ -451,7 +451,7 @@ namespace hpx::parallel {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename FwdIter1, typename FwdIter2>
+        template <typename FwdIter1, typename FwdIter2>
         struct copy_iter<FwdIter1, FwdIter2,
             std::enable_if_t<
                 iterators_are_not_segmented<FwdIter1, FwdIter2>::value>>

libs/core/algorithms/include/hpx/parallel/algorithms/detail/dispatch.hpp

@@ -35,7 +35,7 @@ namespace hpx::parallel::detail {
             Result>::local_raw_iterator;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Result1, typename Result2>
+    template <typename Result1, typename Result2>
     struct local_algorithm_result<util::in_out_result<Result1, Result2>>
     {
         using type1 = typename hpx::traits::segmented_local_iterator_traits<
@@ -46,7 +46,7 @@ namespace hpx::parallel::detail {
         using type = util::in_out_result<type1, type2>;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Result>
+    template <typename Result>
     struct local_algorithm_result<util::min_max_result<Result>>
     {
         using type1 = typename hpx::traits::segmented_local_iterator_traits<
@@ -55,8 +55,7 @@ namespace hpx::parallel::detail {
         using type = util::min_max_result<type1>;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Result1, typename Result2,
-        typename Result3>
+    template <typename Result1, typename Result2, typename Result3>
     struct local_algorithm_result<
         util::in_in_out_result<Result1, Result2, Result3>>
     {

libs/core/algorithms/include/hpx/parallel/algorithms/for_each.hpp

@@ -327,7 +327,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F>
+        template <typename ExPolicy, typename F>
         struct for_each_iteration<ExPolicy, F, hpx::identity>
         {
             using execution_policy_type = std::decay_t<ExPolicy>;

libs/core/algorithms/include/hpx/parallel/algorithms/for_loop.hpp

@@ -811,8 +811,7 @@ namespace hpx::parallel {
             typename S = void, typename Tuple = hpx::tuple<>>
         struct part_iterations;
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F, typename S,
-            typename... Ts>
+        template <typename ExPolicy, typename F, typename S, typename... Ts>
         struct part_iterations<ExPolicy, F, S, hpx::tuple<Ts...>>
         {
             using fun_type = std::decay_t<F>;
@@ -915,7 +914,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F, typename S>
+        template <typename ExPolicy, typename F, typename S>
         struct part_iterations<ExPolicy, F, S, hpx::tuple<>>
         {
             using fun_type = std::decay_t<F>;
@@ -1016,8 +1015,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F,
-            typename... Ts>
+        template <typename ExPolicy, typename F, typename... Ts>
         struct part_iterations<ExPolicy, F, void, hpx::tuple<Ts...>>
         {
             using fun_type = std::decay_t<F>;
@@ -1097,7 +1095,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F>
+        template <typename ExPolicy, typename F>
         struct part_iterations<ExPolicy, F, void, hpx::tuple<>>
         {
             using fun_type = std::decay_t<F>;

libs/core/algorithms/include/hpx/parallel/algorithms/for_loop_induction.hpp

@@ -58,7 +58,7 @@ namespace hpx::parallel::detail {
         T curr_;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct induction_helper<T&>
     {
         explicit constexpr induction_helper(T& var) noexcept
@@ -138,7 +138,7 @@ namespace hpx::parallel::detail {
         std::size_t stride_;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct induction_stride_helper<T&>
     {
         constexpr induction_stride_helper(T& var, std::size_t stride) noexcept

libs/core/algorithms/include/hpx/parallel/algorithms/move.hpp

@@ -185,7 +185,7 @@ namespace hpx::parallel {
             typename Enable = void>
         struct move;
 
-        HPX_CXX_CORE_EXPORT template <typename FwdIter1, typename FwdIter2>
+        template <typename FwdIter1, typename FwdIter2>
         struct move<FwdIter1, FwdIter2,
             std::enable_if_t<
                 iterators_are_segmented<FwdIter1, FwdIter2>::value>>
@@ -197,7 +197,7 @@ namespace hpx::parallel {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename FwdIter1, typename FwdIter2>
+        template <typename FwdIter1, typename FwdIter2>
         struct move<FwdIter1, FwdIter2,
             std::enable_if_t<
                 iterators_are_not_segmented<FwdIter1, FwdIter2>::value>>

libs/core/algorithms/include/hpx/parallel/algorithms/shift_right.hpp

@@ -180,7 +180,7 @@ namespace hpx::parallel {
         HPX_CXX_CORE_EXPORT template <typename I, typename Tag, typename = void>
         inline constexpr bool is_category = false;
 
-        HPX_CXX_CORE_EXPORT template <typename I, typename Tag>
+        template <typename I, typename Tag>
         inline constexpr bool is_category<I, Tag,
             std::enable_if_t<
                 std::is_convertible_v<iterator_category_t<I>, Tag>>> = true;
@@ -321,8 +321,7 @@ namespace hpx {
                 std::is_integral_v<Size>
             )
         // clang-format on
-        friend typename hpx::parallel::util::detail::algorithm_result<ExPolicy,
-            FwdIter>::type
+        friend parallel::util::detail::algorithm_result_t<ExPolicy, FwdIter>
         tag_fallback_invoke(shift_right_t, ExPolicy&& policy, FwdIter first,
             FwdIter last, Size n)
         {

libs/core/algorithms/include/hpx/parallel/algorithms/transform.hpp

@@ -332,7 +332,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename F>
+        template <typename F>
         struct transform_projected<F, hpx::identity>
         {
             std::decay_t<F> f_{};
@@ -407,7 +407,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F>
+        template <typename ExPolicy, typename F>
         struct transform_iteration<ExPolicy, F, hpx::identity>
         {
             using execution_policy_type = std::decay_t<ExPolicy>;
@@ -631,7 +631,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F>
+        template <typename ExPolicy, typename F>
         struct transform_binary_iteration<ExPolicy, F, hpx::identity,
             hpx::identity>
         {