Olaf Krzikalla: ...

...

...

template<typename T> void foo(boost::function<T> func) { /*...*/ }

void bar() {}

void baz() { foo(boost::bind(&bar)); // error }

So how do I get the first line of baz to work? That is, is there a generic way to compute the boost::function type from the bind result?

There is not because the boost::function type is not unique. Hmm, indeed. However wouldn't it be possible for the bind (member) function pointer overloads to return a "_bind_t_ex" type derived from _bind_t containing a function_type typedef? In my particular use case I will use bind with function pointers only.

In general you can't deduce a boost::function<> from the result of bind, even if you only use functions. function f1 = bind( bar ); // OK function f2 = bind( bar ); // OK function f3 = bind( bar ); // still OK In fact, this ability to ignore arguments is the primary reason to use bind(bar), if you didn't need it, you could have used just bar.

Why not dispatch on the number of arguments that are available via getArg? You won't then need to know the arity of the function object (assuming it has one and only one arity, which it may not.) I'm not sure if I understand you right. The top level problem is to bind C++ functions in a generic way to LUA

Hi, Peter Dimov wrote: script callbacks. That is I know the actual number of arguments not before runtime. Below is my current solution (LUA specific stuff and the rather obvious ArgTypeDispatcher are stripped): ---snip--- template<class T> struct ArgNumDispatcher; template<> struct ArgNumDispatcher > { static void doFunction(const boost::function& f) { f(); } }; template<class T> struct ArgNumDispatcher > { static void doFunction(const boost::function& f) { f(ArgTypeDispatcher::get()); } }; template struct ArgNumDispatcher > { static void doFunction(const boost::function& f) { f(ArgTypeDispatcher::get(), ArgTypeDispatcher::get()); } }; // aso. struct tFunctionBase { virtual void doFunction() = 0; }; template<class T> struct tFunction : tFunctionBase { tFunction(const T& f) : func(f) {} virtual void doFunction() { int iNumArgs = getNumArguments(); //comes from LUA if (T::arity != iNumArgs) { //some error handling } ArgNumDispatcher<T>::doFunction(func); } T func; }; std::map m_Functions; template<class T> void registerFunction(const std::string& strName, boost::function<T> func) { boost::shared_ptr<tFunctionBase> p (new tFunction(func)); m_Functions.insert(std::make_pair(strName, p)); } ---snip--- This works pretty well so far. However I can't squeeze out this last bit of elegance by calling registerFunction with a bind expression and without explicitely stating the function type in the template parameter. But maybe there is a completely dfferent approach I don't see yet(?). Thanks in advance Olaf Krzikalla