How to bind a function that accepts const char *?

[ubt0001]

I am trying to bind a function that accepts const char * with code like this:

NB_MODULE(interface, m) {
    m.def("failed_to_compile",
          [](const char *c) {},
          "c"_a
    );
}

It gives me the following error:

error: ‘nanobind::detail::make_caster<const char*>’ {aka ‘struct nanobind::detail::type_caster<char>’} has no member named ‘operator nanobind::detail::cast_t<const char*>’
118 |             cap->func(((make_caster<Args>&&) in.template get<Is>()).operator cast_t<Args>()...);
    |                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~

[wjakob]

Well, this is embarrassing. Fixed on master.

[ubt0001]

For "x"_a.none(), the error message is like this:

>>> dbg_char_string(None)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: dbg_char_string(): incompatible function arguments. The following argument types are supported:
    1. dbg_char_string(x: Optional[str]) -> None

Invoked with types: NoneType

[wjakob]

Passing None as parameter values is only permitted for pybind11-bound types and generic parameters like nb::handle or nb::object. IIRC this is not a new limitation, it is also not allowed by pybind11.

You will need to write a lambda function like so:

m.def("test", [](nb::handle h) {
    const char *s = nullptr;
    if (!h.is_none())
       s = nb::cast<const char *>(h);
    ...
});

[ubt0001]

I am not sure whether I use pybind11 correctly, but I can do this with pybind11:

m.def("dbg_char_string", [](const char * c) {
    std::cout << (void *) c << std::endl;
    if (c != nullptr) {
            std::cout << c << std::endl;
    }
}, py::arg("c"));

and get the following output:

>>> dbg_char_string(None)
0
>>> dbg_char_string("test")
0x7fff41751690
test

[ubt0001]

I cannot compile this code with nanobind:

m.def("failed_to_compile",
    [](nb::handle h_x) {
        const char *x = nullptr;
        if (!h_x.is_none()) {
            x = nb::cast<const char *>(h_x);
        }
        if (x != nullptr) {
            std::cout << x << std::endl; 
        } else {
            std::cout << "nullptr" << std::endl;
        }
    },
    "x"_a.none()
);

Compile error message:

error: static assertion failed: nanobind::cast(): cannot return a reference to a temporary.
        303 |             !(std::is_reference_v<T> || std::is_pointer_v<T>) || Caster::IsClass,
            |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~
      /tmp/pip-build-env-hib3u815/overlay/lib/python3.9/site-packages/nanobind/include/nanobind/nb_cast.h:303:63: note: ‘(((!(bool)std::is_reference_v<const char*>) && (!(bool)std::is_pointer_v<const char*>)) || ((bool)nanobind::detail::type_caster<char>::IsClass))’ evaluates to false
      /tmp/pip-build-env-hib3u815/overlay/lib/python3.9/site-packages/nanobind/include/nanobind/nb_cast.h:307:38: error: ‘using Caster = nanobind::detail::make_caster<char>’ {aka ‘struct nanobind::detail::type_caster<char>’} has no member named ‘operator Ti*’
        307 |             return caster.operator Ti*();
            |                    ~~~~~~~~~~~~~~~~~~^

Currently std::string can be used to workaround this problem. This works for me because I don't really care about the performance, but the extra dependency in using stl might be problematic in certain condition.

m.def("dbg_stl_string",
    [](nb::handle h_x) {
        std::string x {};
        const char *x_cstr = nullptr;
        if (!h_x.is_none()) {
            x = nb::cast<std::string>(h_x);
            x_cstr = x.c_str();
            std::cout << x_cstr << std::endl;
        } else {
            std::cout << "None" << std::endl;
        }
    },
    "x"_a.none()
);

[wjakob]

The issue with nb::cast is now fixed in master.