unpack each element of an array into a template parameter - c++

Question

So I have a constexpr array, is there a way to templatize each of its elements as a template parameter, the purpose is that so I can call a function of each of them, but instead of a loop which is runtime, I'd like to call it at compile time, also be able to use static_assert on it? So far I tried the following but it didn't work, the compiler couldn't deduce the proper parameter to the func. I'm using version c++17.
template <auto param, typename Function, typename... Args>
void invoke_param(Function func, Args... args)
{
func(param, args...);
}
template <auto... params, typename Function, typename... Args>
void invoke_params(Function func, Args... args)
{
(invoke_param<params>(func, args...), ...);
}
template <auto& Array, std::size_t... Indices, typename Function, typename... Args>
auto for_each_array_impl(std::index_sequence<Indices...>, Function func, Args... args)
{
invoke_params<Array[Indices]...>(func, args...);
}
template <auto& Array, typename Function, typename... Args>
auto for_each_array(Function func, Args... args)
{
return for_each_array_impl<Array>(
std::make_index_sequence<std::size(Array)>(), func, args...);
}
static constexpr std::array<int, 5> ARR{1,2,3,4,5};
int main() {
auto fun = []<int E>() {
static_assert(E > 0);
//...;
};
for_each_array<ARR>(func);
}

Answer 1

You need to pass param as a template parameter if you want it to be a template parameter
template <auto param, typename Function, typename... Args>
void invoke_param(Function func, Args... args)
{
func.template operator()<param>(args...);
}
As an aside, you need C++20 for []<int E>(), before then you'd have to write it longhand.
See it on coliru

Answer 2

In C++20 we can condense all the boilerplate down into a single function thanks to template lambdas and expanded auto parameters:
Live Demo
template<auto& arr, auto F>
consteval auto for_each_array()
{
[]<auto... indices>(std::index_sequence<indices...>)
{
(F.template operator()<arr[indices]>(), ...);
}(std::make_index_sequence<arr.size()>{});
}
static constexpr std::array<int, 5> ARR{1,2,3,4,5};
int main() {
constexpr auto fun = []<int E>()
{
static_assert(E > 0);
//...
};
for_each_array<ARR, fun>();
}
for_each_array creates a helper lambda and immediately invokes it, making use of a fold-expression to call your function for each array value.
EDIT:
C++17 version
template<auto& arr, class F, auto... indices>
constexpr auto for_each_array_impl(F callable, std::index_sequence<indices...>)
{
(callable.template operator()<arr[indices]>(), ...);
}
template<auto& arr, class F>
constexpr auto for_each_array(F&& callable)
{
for_each_array_impl<arr>(std::forward<F>(callable),
std::make_index_sequence<arr.size()>{});
}
Called like so:
struct fun
{
template <int E>
void operator()()
{
static_assert(E > 0);
//...
}
};
static constexpr std::array<int, 5> ARR{1,2,3,4,5};
int main() {
for_each_array<ARR>(fun{});
}