Wrapping free functions as class methods

[ianhbell]

I have a large collection of template-heavy free functions, something like:

template<typename Model, typename Arg> foo(const Model model, Arg a1, Arg a2){ ... }
template<typename Model, typename Arg> bar(const Model model, Arg a1, Arg a2){ ... }
template<typename Model, typename Arg> baa(const Model model, Arg a1, Arg a2){ ... }
template<typename Model, typename Arg> bad(const Model model, Arg a1, Arg a2){ ... }
...

And wrapping them works fine with:

m.def(...)

The compiler requires a frankly ridiculous amount of RAM (10 GB or more) to compile my library where maybe there are 8 model types, and 20 functions. The problem is most severe with MSVC, but not only. Of course deeply nested template libraries are a big part of the problem here.

I think part of the problem is that the overload resolution of foo, bar, ... are causing trouble for the compiler. I am therefore trying to figure out how to attach all the free functions to instances of model in the interface because method lookup on an instance is much, much faster than overload resolution on a free function. I tried to make a wrapper class something like

// A helper class to take a free function that takes a model as first
// argument and turn it into a callable object. All other arguments
// are passed along by perfect forwarding
template<typename Callable>
struct FreeFunctionWrapper{
    Callable &f;
    FreeFunctionWrapper(Callable &f) : f(f) {};

    template<typename Model, typename... Args>
    auto operator()(const Model &m, Args&&... args){
        return std::apply(f, m, std::forward<Args>(args)...);
    }
};

but it doesn't work and I get pages of compilation errors. I think the issue is I don't know how to pass along something like &foo to be held and then used by the wrapper class. I'd like to have tens or hundreds of model types, which is currently unfeasible.

Of course, writing lambda functions to hoist free functions into the instance is possible, if VERY tedious:

cls.def("get_Ar00", [](const Model& m, const double T, const double rho, const RAX molefrac) { return tdx::get_Ar00(m, T, rho, molefrac); }, py::arg("T"), py::arg("rho"), py::arg("molefrac").noconvert());
cls.def("get_Ar01", [](const Model& m, const double T, const double rho, const RAX molefrac) { return tdx::template get_Ar01<ADBackends::autodiff>(m, T, rho, molefrac); }, py::arg("T"), py::arg("rho"), py::arg("molefrac").noconvert());
cls.def("get_Ar10", [](const Model& m, const double T, const double rho, const RAX molefrac) { return tdx::template get_Ar10<ADBackends::autodiff>(m, T, rho, molefrac); }, py::arg("T"), py::arg("rho"), py::arg("molefrac").noconvert());
cls.def("get_Ar11", [](const Model& m, const double T, const double rho, const RAX molefrac) { return tdx::template get_Ar11<ADBackends::autodiff>(m, T, rho, molefrac); }, py::arg("T"), py::arg("rho"), py::arg("molefrac").noconvert());
cls.def("get_Ar12", [](const Model& m, const double T, const double rho, const RAX molefrac) { return tdx::template get_Ar12<ADBackends::autodiff>(m, T, rho, molefrac); }, py::arg("T"), py::arg("rho"), py::arg("molefrac").noconvert());
cls.def("get_Ar20", [](const Model& m, const double T, const double rho, const RAX molefrac) { return tdx::template get_Ar20<ADBackends::autodiff>(m, T, rho, molefrac); }, py::arg("T"), py::arg("rho"), py::arg("molefrac").noconvert());

[ianhbell]

I guess what I need is sort of the opposite of std::mem_fn, but I don't know how to approach the problem.