Why does bind_vector generate __eq__ even if value type is not comparable?

[tom-bola]

Title says it. Given a type

struct NonComparable {
    int i = 2;
};

and bindings

        nanobind::class_<NonComparable>(m, "NonComparable")
            .def(nanobind::init<>())
            .def_rw("i", &NonComparable::i);

        nanobind::bind_vector<std::vector<NonComparable>>(m, "Vec");

the Vec will have an __eq__ method but the comparison is not by value:

    v1 = Vec([NonComparable()])
    v2 = Vec([NonComparable()])
    v1[0].i = 2
    v2[0].i = 2
    assert hasattr(v1, '__eq__')  # OK
    assert v1 == v2  # FAILS

Looking into bind_vector.h the synthesis of equality should be guarded by

    if constexpr (detail::is_equality_comparable_v<Value>) {
        ...
    }

so I'd expect Vec to not have an __eq__ method.

[wjakob]

Could I ask you to make a PR to fix this?

[tom-bola]

I yet don't understand where the __eq__ is coming from. static_assert(!nanobind::detail::is_equality_comparable_v<NonComparable>) holds, so this was a genuine question.

[tom-bola]

So this is coming from python's default object comparison, which compares by id IIUC. The options that we have

1. Leave unimplemented

        cl.def(
              "__eq__", [](handle, handle) { return borrow<object>(Py_NotImplemented); },
              sig("def __eq__(self, arg: object, /) -> bool"))
            .def(
                "__ne__", [](handle, handle) { return borrow<object>(Py_NotImplemented); },
                sig("def __ne__(self, arg: object, /) -> bool"));

However, this falls back to identity-based comparison, so it doesn't change the behavior.
2. Throw

        cl.def(
              "__eq__", [](handle, handle) { throw std::runtime_error("Not implemented"); },
              sig("def __eq__(self, arg: object, /) -> bool"))
            .def(
                "__ne__", [](handle, handle) { throw std::runtime_error("Not implemented"); },
                sig("def __ne__(self, arg: object, /) -> bool"));

This might break existing code.