Why can't this parameter pack accept function pointers?

Question

I'm trying to create a parameter pack full of function pointers, but GCC (with c++17 standard) generates a deduction failed error. Why is that?

As written here:

For pointers to functions, the valid arguments are pointers to functions with linkage (or constant expressions that evaluate to null pointer values).

In my example, that's the case (isn't it?).

Is this rule invalidated for parameter packs? Did I miss something in the standard? If that's the case, how can I fix my code, without passing the function pointers as function arguments (ie without declaring T run2(T input, Funcs... funcs).

// In f.hpp
template<typename T>
T run2(T input)
{
    return input;
}

template<typename T, T(*f)(T), class ... Funcs>
T run2(T input)
{
    return run2<T, Funcs...>(f(input));
}

// In m.cpp
unsigned add2(unsigned v)
{
    return v+2;
}

int main()
{
    unsigned a=1;
    a = run2<unsigned, add2>(a); // works
    a = run2<unsigned, add2, add2>(a); // doesn't work
    std::cout << a << std::endl;

    return 0;
}

This the error I get with run2<unsigned, add2, add2> (GCC doesn't tell me why the last attempt actually failed):

m.cpp: In function ‘int main()’:
m.cpp:37:37: error: no matching function for call to ‘run2(unsigned int&)’
     a = run2<unsigned, add2, add2>(a);
                                     ^
In file included from m.cpp:2:0:
./f.hpp:85:3: note: candidate: template<class T> T run2(T)
 T run2(T input)
   ^
./f.hpp:85:3: note:   template argument deduction/substitution failed:
m.cpp:37:37: error: wrong number of template arguments (3, should be 1)
     a = run2<unsigned, add2, add2>(a);
                                     ^
In file included from m.cpp:2:0:
./f.hpp:109:3: note: candidate: template<class T, T (* f)(T), class ... Funcs> T run2(T)
 T run2(T input)
   ^
./f.hpp:109:3: note:   template argument deduction/substitution failed:

Answer 1

You declared a type parameter pack, class... Funcs. You can't pass function pointers as arguments for type parameters, because they are values, not types. Instead, you need to declare the run2 template so that it has a function pointer template parameter pack. The syntax to do so is as follows:

template<typename T, T(*f)(T), T(*...fs)(T)>
T run2(T input)
{
    return run2<T, fs...>(f(input));
}

(The rule is that the ... is part of the declarator-id and goes right before the identifier, namely fs.)

The pack fs can accept one or more function pointers of type T (*)(T).