Передача функции constexpr для использования во время компиляции

Я пытаюсь сделать простой способ генерации std::array во время компиляции. До сих пор это была борьба за то, чтобы найти хороший способ передать функцию constexpr во время компиляции. Обходной путь, который я нашел до сих пор, выглядит следующим образом.

#include <iostream>                                                                
#include <array>                                                                   
namespace a {                                                                      
constexpr int f(const int & i) { return i * i * i;}                                
#include "generate_with_function.hpp"                                              
}                                                                                  
int main()                                                                         
{                                                                                  
    auto arr  = a::generator<false,10,0>::array;                                   
    for (auto i : arr) {                                                           
        std::cout << i << " ";                                                     
    }                                                                              
    return 0;                                                                      
}  

это в основном предполагает, что вы определите функцию, называемую f и я завернул ее в пространство имен, я хотел бы сделать другое. Я хотел знать, есть ли более умный способ передать функцию и использовать ее во время компиляции. Также здесь приведен код, который составляет список.

template <bool B, size_t Count,int ... Nums>                                       
struct generator;                                                                  

template <size_t Count>                                                            
struct generator<false,Count,0>                                                    
{                                                                                  
    constexpr static std::array<int,Count> array                                   
        = generator<false,Count,1,f(0)>::array;                                    
};                                                                                 

template <size_t Count, int Current, int ... Results>                              
struct generator<false,Count,Current, Results...>                                  
{                                                                                  
    constexpr static std::array<int,Count>  array                                  
        = generator<Current+1==Count,Count,Current+1,f(Current), Results...>::array;
};                                                                                 

template <size_t Count, int Current, int ... Results>                              
struct generator<true,Count,Current,Results...>                                    
{                                                                                  
    constexpr static std::array<int,Count>  array{{Results...}};                   
}; 

и прежде чем вы спросите, у меня нет реальной потребности в этом.

Как отмечалось в @us2012, я должен быть конкретным относительно того, что я бы предпочел.

1. nowrapping в пространстве имен
2. чтобы написать функцию, но не передавать ее в любом месте
3. и не требуя, чтобы функция называлась f