Estoy tratando de simplificar (a través demake_fn()) la generación de funtores que preprocesan parámetros (a través dewrap()) para funciones miembro de arityn.
La generación de los funtores funciona básicamente, pero hasta ahora solo especificando explícitamente los tipos de parámetros para la función miembro.
Ahora me gustaría generar el functor correcto a partir del tipo de función miembro que maneja:

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);
}

Sin embargo, con esto, vc ++ y g ++ no venF como un tipo para el parámetro demake_fn(). Debo perderme algo obvio aquí y me siento algo ciego.

La idea era que debería funcionar así:

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

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

¿Alguna idea sobre cómo hacer que funcione?

Fondo:
Tengo una interfaz fija que, cuando se simplifica, se ve así:

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

X es un tipo de variante que tengo que convertir a ciertos tipos de backend (int, std :: string, ...).
Para manejar estas llamadas tengo un mapa de los funtores que se buscan por nombre y asigno estas llamadas a las funciones miembro de alguna instancia.
La intención del envoltorio es evitar las conversiones manuales y, en cambio, generar funtores que hagan la conversión por mí othrow. Tengo este trabajo con una solución basada en macros, pero esa solución requiere especificar los tipos y el número de parámetros explícitamente.
A través de la resolución de sobrecarga de la función, espero generar el funtor de conversión correcto implícitamente a partir de la firma de la función miembro.