I've asked this question on Stack Overflow but not found a solution yet:
http://stackoverflow.com/q/20578575/67013.  It's
Boost.Function/MPL-related so I'll ask here too.

I'm trying to create something like a `boost::function`, but with an
extra 'smart handle' tucked inside, which controls the lifetime of a
resource the functions needs to execute correctly.

If I didn't need the function signature to be completely generic, this
would be easy.  I would just create a functor with the correct
signature, and keep a `boost::function` and the handle as members.

However, I do need generic signatures.  The code below is as close as
I've got but gets a compile error, presumably, because I'm not able to
unpack a list of arguments like this:

 template<typename Signature>
 class library_function
 {
 public:
     library_function(
         library_handle handle,
         boost::function<result_type(arg1_type, arg2_type)> function)
         :
     m_handle(handle),
     m_function(function)
     {}

     typename result_type operator()(arg1_type arg1, arg2_type arg2)
     {
         return m_function(arg1, arg2);
     }

     // I don't think I can declare the 'params' like this ...
     typename boost::function_types::result_type<Signature>::type operator()(
         boost::function_types::parameter_types<Signature> params)
     {
         return m_function(params); // ... nor unpack them like this
     }

 private:
     boost::function<Signature> m_function;
     library_handle m_library;
 };

I think `params` is an MPL list, so what I've actually done is declare a
call operator with a single MPL-list parameter.  My MPL-foo is not good.
Is there a way to convert the list to a legal definition of multiple
function paramters?