Implicit conversion issue with None

[mdcb]

Here's a minimal test-case to illustrate the issue:

struct Any {
    Any(py::object & obj) {}
};

void foo (Any & obj) {}

...

py::class_<Any>(m, "Any")
    .def(py::init<py::object>());

m.def("foo", &foo);

py::implicitly_convertible<py::object, Any>();

This results in:

>>> foo(123) # ok
>>> foo('')  # ok
>>> foo([])  # ok
>>> foo({})  # ok
>>> foo(None)
TypeError: foo(): incompatible function arguments. The following argument types are supported:
    1. (arg0: test.Any) -> None

Invoked with: None

[jagerman]

Interesting. This is happening because we explicitly disallow None in type_caster_generic::load() (the base type caster for user-declared types):

        if (src.is_none()) {
            value = nullptr;
            return true;
        }

which usually seems pretty reasonable, but does indeed cause this.

[wjakob]

I think this is a little bit too obscure of a use case to warrant changing the library.

[crisluengo]

I don't think this is a strange use case. None is used in Python to explicitly indicate an optional argument is not given.

I have a C++ class dip::Image. A default-constructed dip::Image{} doesn't have any memory allocated for pixels. Some functions that take a dip::Image as input behave differently if the image is default-constructed. For example,

dip::Image image = ...
dip::Image mask = ...
double mean = dip::Mean(image, mask);

computes the mean over the region of the image selected by the mask image. It is possible to call this as

double mean = dip::Mean(image, {});

to indicate that the mean should be computed over all pixels.

In Python, I can currently do

mean = dip.Mean(image, dip::Image())

which is not very pretty. Instead,

mean = dip.Mean(image, None)

would look quite a bit better. Unfortunately it seems impossible to take None as input to a function. I thought the following should work:

auto img = py::class_< dip::Image >( m, "Image", py::buffer_protocol() );
// ...
img.def( py::init( []( py::none const& ) { return dip::Image{}; } ), "none"_a );
py::implicitly_convertible< py::none, dip::Image >();

I can now do dip.Image(None), but I cannot call a function that expects a dip.Image as input with the argument None.

I don't want to add an additional interface to each function to allow it to accept None, the implicit conversion should be taking care of this.

---

What would be the consequence of allowing None in type_caster_generic::load()?