Allow multiple signatures for lambda/callback function as template parameter - c++

Question

I want to allow multiple signatures for a callable whose type is specified as a template parameter. More specifically, I have a templated update method, which takes a callable that must return a float, and uses it to update values in a grid of data. A simplified illustration of this is
template <typename Fn>
void update(Fn&& fn_)
{
for (Vec3 pos : m_grid)
{
float val = fn_(pos, m_grid)
m_grid(pos) = val;
...
In the above case, the signature of the fn_ must always have both a pos and a grid as parameters, even if they are ignored in the implementation
I would like to use some template magic to allow multiple permutations of callback signatures.
In particular, I would like to allow callbacks that take pos but not grid, and callbacks that take no parameters at all. I don't mind whether the ordering of parameters is enforced or not.
Anyone any hints on how to do this? I don't mind using boost or other libraries, but they should be header-only.

Answer 1

You could do this with a helper function using SFINAE using is_invocable (C++17: std::is_invocable, or earlier with boost: boost::callable_traits::is_invocable)
template <typename Fn,
std::enable_if_t<std::is_invocable<Fn, Vec3, Grid>::value>* = nullptr>
float call_helper(Fn&& fn_, const Vec3& pos_, const Grid& grid_)
{
return fn_(pos_, grid_);
}
template <typename Fn,
std::enable_if_t<std::is_invocable<Fn, Vec3>::value>* = nullptr>
float call_helper(Fn&& fn_, const Vec3& pos_, const Grid& grid_)
{
return fn_(pos_);
}
template <typename Fn,
std::enable_if_t<std::is_invocable<Fn, Grid>::value>* = nullptr>
float call_helper(Fn&& fn_, const Vec3& pos_, const Grid& grid_)
{
return fn_(grid_);
}
template <typename Fn>
void update(Fn&& fn_)
{
for (Vec3 pos : m_grid)
{
float val = call_helper(fn_, pos, m_grid)
m_grid(pos) = val;
...

Answer 2

In particular, I would like to allow callbacks that take pos but not grid, and callbacks that take no parameters at all.
Just define two overloads and use lambdas to do that by forwarding the request to the complete function and thus filtering the extra parameters.
As a minimal, working example:
struct S {
template <typename Fn>
auto update(Fn &&fn_)
-> decltype(fn_(0, 0), void())
{
// ...
fn_(0, 0);
// ...
}
template <typename Fn>
auto update(Fn &&fn_)
-> decltype(fn_(0), void())
{ update([&fn_](auto a, auto) { fn_(a); }); }
template <typename Fn>
auto update(Fn &&fn_)
-> decltype(fn_(), void())
{ update([&fn_](auto, auto) { fn_(); }); }
};
int main() {
S s;
s.update([](auto, auto) {});
s.update([](auto) {});
s.update([]() {});
}