Template functions

[nils-werner]

Is it possible to define template functions like

#include <pybind11/pybind11.h>
#include <pybind11/numpy.h>

namespace py = pybind11;

template <typename T>
T square(T x) {
    return x * x;
}

void pyexport(py::module& m) {
    m.def("square", &square);
}

I always get error messages like

/var/folders/h9/w6465dvd31l5f4bd_j49_4cw0000gp/T/tmpNUt8Ir/ctest.cpp:50:7: error: no matching member function for call to 'def'
    m.def("square", &square);
    ~~^~~
/virtualenv/include/site/python2.7/pybind11/pybind11.h:487:13: note: candidate template ignored: couldn't infer template argument 'Func'
    module &def(const char *name_, Func &&f, const Extra& ... extra) {
            ^
1 error generated.
error: command 'clang' failed with exit status 1

or, when using py::vectorize

/var/folders/h9/w6465dvd31l5f4bd_j49_4cw0000gp/T/tmpc0aYol/ctest.cpp:49:21: error: no matching function for call to 'vectorize'
    m.def("square", py::vectorize(&square));
                    ^~~~~~~~~~~~~
/virtualenv/include/site/python2.7/pybind11/numpy.h:379:66: note: candidate template ignored: couldn't infer template argument 'Return'
detail::vectorize_helper<Return (*) (Args ...), Return, Args...> vectorize(Return (*f) (Args ...)) {
                                                                 ^
/virtualenv/include/site/python2.7/pybind11/numpy.h:383:31: note: candidate template ignored: couldn't infer template argument 'func'
template <typename func> auto vectorize(func &&f) -> decltype(
                              ^
/virtualenv/include/site/python2.7/pybind11/numpy.h:374:49: note: candidate function template not viable: requires 2 arguments, but 1 was provided
detail::vectorize_helper<Func, Return, Args...> vectorize(const Func &f, Return (*) (Args ...)) {
                                                ^
1 error generated.
error: command 'clang' failed with exit status 1

[wjakob]

You can only bind explicitly instantiated versions of your function, e.g. square<int>

[nils-werner]

Ah, OK! Just for reference, this works:

#include <pybind11/pybind11.h>
#include <pybind11/numpy.h>

namespace py = pybind11;

template <typename T>
T square(T x) {
    return x * x;
}

void pyexport(py::module& m) {
    m.def("square", square<double>);
    m.def("square", square<float>);
    m.def("square", square<int>);
}

[PaulSt]

Also just for reference, for classes it works like so

#include <pybind11/pybind11.h>
#include <pybind11/numpy.h>

namespace py = pybind11;

template <typename T>
class C : public SuperClass
{
 C(int foo)	{}
 void func (int baa)
}

template <typename T>
void C<T> :: func(int baa) {}

PYBIND11_MODULE(example, m) {
py::class_< C<double>, shared_ptr< C<double> >, SuperClass>(m, "C")
 .def(py::init<int>())
 .def("func", &C<double>::func);
}

[Pulsar18]

@PaulSt: what do you need the shared_ptr for in the class binding?

[leimao]

If I don't use template functions, but still have overloaded functions, for example (for some declarations):

int add(int a, int b);
float add(float a, float b);

Does this mean pybind11 has no solution for this? Even if I want to map the first add to Python function, say, add1, and map the second add to Python function, say, add2?

[leimao]

Does this mean, if I don't use template functions, but still have overloaded functions, for example (for some declarations):

int add(int a, int b);
float add(float a, float b);

Does this mean pybind11 has no solution for this? Even if I want to map the first add to Python function, say, add1, and map the second add to Python function, say, add2?

Ah, I need to use py::overload_cast with C++ standard 14 for overloaded functions.

[jxramos]

How would one bind a template function where the template argument is behind other arguments?

template <typename T>
T square(const char* id, int previous, T x) {
    std::cout << "id = " << id << std::endl;
    return previous* x * x;
}

[bstaletic]

.def("square_int", square<int>) // For example

[jlucier]

For anyone coming across this post confused on how to bind template member functions, I have a solution / questions that would probably be useful to share.

1. There are situations where it seems to work perfectly to use the "naive" binding shown below. I don't know why, but sometimes the compiler is totally happy with that code and other times it is very unhappy. My C++ naivete is probably showing.
2. On other occasions, you will get some cryptic errors like error: expected primary-expression before '>' token (referring to the closing > in that line of code). The only remedy I've discovered is to include a pretty sneaky template keyword in the binding definition. Someone more versed in C++ can explain in detail why this makes perfect sense, but this was hard for me to find.

class Foo {
    template<typename T>
    void foo(T t) {
         ...
    }
};

// naive bind that seems to sometimes work and sometimes not work
m.def("foo", &Foo::foo<double>);

// use this to bind (also works for static members), replacing double with whatever specialization
m.def("foo", &Foo::template foo<double>);

Does this make any sense? Any thoughts?