Eu estou tentando fazer este programa compilar corretamente:

#include <vector>
#include <iostream>

int f(int a, int b)
{
   ::std::cout << "f(" << a << ", " << b << ") == " << (a + b) << '\n';
   return a + b;
}

template <typename R, typename V>
R bind_vec(R (*f)(), const V &vec, int idx=0)
{
   return f();
}

template <typename R, typename V, typename Arg1, typename... ArgT>
R bind_vec(R (*f)(Arg1, ArgT...), const V &vec, int idx=0)
{
   const Arg1 &arg = vec[idx];
   auto call = [arg, f](ArgT... args) -> R {
      return (*f)(arg, args...);
   };
   return bind_vec(call, vec, idx+1);
}

int foo()
{
   ::std::vector<int> x = {1, 2};
   return bind_vec(f, x);
}

Idealmente eu gostariabind_vec para ter um functor arbitrário como um argumento em vez de apenas um ponteiro de função. A ideia é puxar os argumentos da função de um::std::vector em tempo de compilação.

Este não é o uso final para isso, mas é um trampolim para onde eu quero ir. O que eu realmente estou fazendo é gerar funções de wrapper que desdobram seus argumentos de promessas em um futuro / tipo de sistema de promessa em tempo de compilação. Essas funções de wrapper serão promessas.

No meu último caso de uso, posso contar com os functores sendo::std::functions. Mas seria bom ter uma ideia de como deveria funcionar para os functores mais gerais, já que acho que esse é um problema amplamente interessante.