Put into a detail namespace

src/targets/gpu/kernels/include/migraphx/kernels/array.hpp

@@ -37,37 +37,38 @@ namespace migraphx {
     template <class U>                                                                      \
     constexpr array& operator op(const array<U, N>& x)                                      \
     {                                                                                       \
-        array_for_each(*this, x)([](auto& sy, auto sx) { sy op sx; });                      \
+        array_detail::array_for_each(*this, x)([](auto& sy, auto sx) { sy op sx; });                      \
         return *this;                                                                       \
     }                                                                                       \
     template <class U, MIGRAPHX_REQUIRES(is_convertible<U, T>{})>                           \
     constexpr array& operator op(const U& x)                                                \
     {                                                                                       \
-        array_for_each (*this)([&](auto& sy) { sy op x; });                                 \
+        array_detail::array_for_each (*this)([&](auto& sy) { sy op x; });                                 \
         return *this;                                                                       \
     }                                                                                       \
     template <class U>                                                                      \
     friend constexpr auto operator binary_op(const array& x, const array<U, N>& y)          \
     {                                                                                       \
         array<decltype(T {} binary_op U{}), N> z{};                                         \
-        array_for_each(z, x, y)([&](auto& sz, auto sx, auto sy) { sz = sx binary_op sy; }); \
+        array_detail::array_for_each(z, x, y)([&](auto& sz, auto sx, auto sy) { sz = sx binary_op sy; }); \
         return z;                                                                           \
     }                                                                                       \
     template <class U, MIGRAPHX_REQUIRES(is_convertible<U, T>{})>                           \
     friend constexpr auto operator binary_op(const array& x, const U& y)                    \
     {                                                                                       \
         array<decltype(T {} binary_op U{}), N> z{};                                         \
-        array_for_each(z, x)([&](auto& sz, auto sx) { sz = sx binary_op y; });              \
+        array_detail::array_for_each(z, x)([&](auto& sz, auto sx) { sz = sx binary_op y; });              \
         return z;                                                                           \
     }                                                                                       \
     template <class U, MIGRAPHX_REQUIRES(is_convertible<U, T>{})>                           \
     friend constexpr auto operator binary_op(const U& x, const array& y)                    \
     {                                                                                       \
         array<decltype(T {} binary_op U{}), N> z{};                                         \
-        array_for_each(z, y)([&](auto& sz, auto sy) { sz = x binary_op sy; });              \
+        array_detail::array_for_each(z, y)([&](auto& sz, auto sy) { sz = x binary_op sy; });              \
         return z;                                                                           \
     }
 
+namespace array_detail {
 template <class T>
 constexpr auto is_vectorizable()
 {
@@ -114,6 +115,8 @@ constexpr auto array_for_each(T& x, Ts&... xs)
         }
     };
 }   
+} // namespace array_detail
+
 
 template <class T, index_int N>
 struct array