Eu estou tentando simplificar (viamake_fn()) a geração de functores que pré-processam parâmetros (viawrap()) para funções-membro da aridaden.
Gerar os functores está basicamente funcionando, mas até agora apenas explicitamente especificando os tipos de parâmetro para a função de membro.
Agora eu gostaria de gerar o functor correto do tipo de função de membro que ele manipula:

struct X {};

template<class C, typename T1, bool (C::*F)(T1)>
inline // there are more for T1..TN
bool wrap(C* c, X x) 
{
    return (c->*F)(process<T1>(x));
}

template<class C, typename T1, bool (C::*F)(T1)> 
inline // there are more for T1..TN
boost::function<bool (C*, X)> make_fn(F f) // <- problem here, F is not a type
{
    return boost::bind(&wrap<C, T1, F>, _1, _2);
}

Com isso, no entanto, vc ++ e g ++ não vêemF como um tipo para o parâmetro demake_fn(). Eu devo sentir falta de algo óbvio aqui e estou me sentindo um pouco cego.

A ideia era que deveria funcionar assim:

struct A 
{
    bool f1(bool) { return true; }
};

void test()
{
    A a;
    X x;
    make_fn(&A::f1)(&a, x);
}

Alguma idéia de como fazer isso funcionar?

Fundo:
Eu tenho uma interface fixa que, quando simplificada, se parece com isso:

bool invoke(C* c, const char* const functionName, int argCount, X* args);

X é um tipo de variante que eu tenho que converter para certos tipos de back-end (int, std :: string, ...).
Para lidar com essas chamadas, eu tenho um mapa de functores que são procurados pelo nome e mapeiam essas chamadas para funções de membro de alguma instância.
A intenção da embalagem é evitar conversões manuais e, em vez disso, gerar functores que fazem a conversão para mim outhrow. Eu tenho isso trabalhando com uma solução baseada em macro, mas essa solução requer especificar os tipos e a contagem de parâmetros explicitamente.
Através da resolução de sobrecarga de função, espero gerar implicitamente o functor de conversão correto da assinatura da função de membro.