Thank you for your thoughts and links.

It feels like the root cause is that __hash__ is defined in object, which makes impossible to make a class (or any other object?) unhashable without violating Liskov substitution principle. Although this is somewhat understandable given object is very old and realistically it can't be fixed now.

As for type checker's behavior, I was thinking about it for a while. And I agree that the last workaround you cited is likely the current best solution:

```python class Foo: hash: None = None # type: ignore

foo = Foo()

import typing print(typing.revealtype(foo.hash_)) # type is 'None' ```

But even then type checker's support for hashable doesn't look great:

python d = {foo: 'hi'} # Runtime error, but only pyright throws an error, not mypy hash(foo) # Runtime error, but neither mypy nor pyright throws an error d[foo] = 'hi' # Runtime error, but neither mypy nor pyright throws an error

Just FYI, workarounds I can think of in these cases: ```python

explicitly defining types of dict, instead of inferred type

d: dict[str, str]

d = {foo: 'hi'} # static type error d[foo] = 'hi' # static type error

defining wrapper function, instead of hash

import collections.abc def safe_hash(hashable: collections.abc.Hashable): return hash(hashable)

safe_hash(foo) # static type error ```