class MyClass:
        def __eq__(self, other):
            if not isinstance(other, MyClass):
                return NotImplemented
            else:
                # whatever your comparison is

This is neat because it allows you to define a class B that can compare equal to an existing class A with the expression A == B, even though class A has no knowledge of B.

In your example, `foo` could be marked (in mypy) a `Union[Foo, int]`, which would be a reasonable value to compare against an `int` and not a type error.

For an example, consider `np.eye(4) == 1`. In this, you're comparing a doubly nested array of floats with a scalar int, but the operation is well defined (vectorized equality comparison).

And yes, it should be feasible to typecheck that operation.

Well, actually as long as they implement the right dundermethods, they can totally be.

For instance:

  from typing import Protocol


  class MyClass:
      def method_a(self) -> None:
          ...

      def method_b(self) -> None:
          ...


  class ProtocolA(Protocol):
      def method_a(self) -> None:
          ...


  class ProtocolB(Protocol):
      def method_b(self) -> None:
          ...


  def compare(a: ProtocolA, b: ProtocolB):
      if a == b:
          print("a == b")
      else:
          print("a != b")


  a = MyClass()
  b = MyClass()

  compare(a, b)

No comparison without explicit casts is a valid design choice. I think Ada and Rust work that way, though I've never used either language and might be mistaken...

Sure, but that wasn't the claim.

How you view the claim itself depends on your thoughts about the level at which equality should operate (should type tags be considered part of a value's identity, is it about the bit representation, or the abstract value encoded by that representation, ...)

There are two forms of equality in Java:

- 'x == y' is an identity check, like 'x is y' in Python (are x and y referencing the same memory?). These must be of the same type, or else it won't compile.

- 'x.equals(y)' is an overridable method, like 'x == y' in Python. Its argument is of type 'Object', so it will accept anything.

I don't do much Java these days, but I do write a lot of Scala (which runs on the JVM). One of the first things I do in a Scala project is load the 'cats' package so I can use 'x.eqv(y)' which refuses to compile if x and y are of incompatible types. This problem also propagates up through different APIs, e.g. 'x.contains(y)' checks whether y appears in the collection x (which could be a list, hashmap, etc.); this doesn't check the types, and I've ended up with bugs that would have been caught if it were stricter. I now prefer to define a safer alternative 'x.has(y)' which uses 'x.exists(z => z.eqv(y))'.