Cannot bind std::bind/std::mem_fn(/std::function) although lambda can be bound

[cielavenir]

This code works:

#include <stdio.h>
#include <functional>

class C{
public:
    int f(int y, int z){return y+z;}
};

main(){
C c;
auto f1 = std::bind(std::mem_fn(&C::f), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
auto f2 = [](C &c, int y, int z){return c.f(y,z);};
printf("%d\n",f1(c,2,3));
printf("%d\n",f2(c,2,3));
}

However this code (f1) does not compile (even though f2 compiles):

#include <functional>
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>

namespace py = pybind11;
using namespace pybind11::literals;

class C{
public:
    int f(int y, int z){return y+z;}
};

PYBIND11_MODULE(C, m){
    py::class_<C>(m, "C")
    .def("f1", std::bind(std::mem_fn(&C::f), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3))
    .def("f2", [](C &c, int y, int z){return c.f(y,z);})
    ;
}

what I see is:

pybind11/detail/common.h:795:11: error: ‘decltype’ cannot resolve address of overloaded function
    795 |     using type = typename remove_class<decltype(&F::operator())>::type;
        |           ^~~~

is this spec or bug of pybind11('s resolver)?

---

my first intention is this:

template<class R, class T, class... Args>
R FirstArgReturner(std::function<void(T&, R&, Args...)> F, T& inst, Args... args)
{
    R r;
    F(inst, r, args...);
    return r;
}

class C{
public:
    void f(int &x, int y, int z){x=y+z;}
};

// now I want to bind std::bind(&FirstArgReturner<int,C,int,int>,std::mem_fn(&C::f),std::placeholders::_1,std::placeholders::_2,std::placeholders::_3), but it does not compile
// there are tons of void-1st_arg_ref functions and using lambda is a little tedious...

[cielavenir]

This worked for my case:

template<typename R, typename C, typename... Args>
struct FirstArgReturner
{
    template<void (C::*F)(R&, Args...)>
    static R func(C& inst, Args... args)
    {
        /*
        Let F is a member function which returns void and the first argument is reference.
        Now these two have the same meaning:
        1.  FirstArgReturner<R,C,Args...>::with(&C::F)
        2.  [](C& inst, Args... args){
                R r;
                C.F(r, args...);
                return r;
            }
        */
        R r;
        (inst.*F)(r, args...);
        return r;
    }
};

def("f1", &FirstArgReturner<int, C, int, int>::func<&C::f>)