How detect hashable types with structural pattern matching?

Solution

The Hashable abstract base class in collections.abc can recognize types that implement hashing using tests like isinstance(obj, Hashable) or issubclass(cls, Hashable).

According to PEP 622, for a class pattern, "whether a match succeeds or not is determined by the equivalent of an isinstance call."

So, you can use Hashable directly in a class pattern:

from collections.abc import Hashable

for obj in [], (), set(), frozenset(), 10, None, dict():
    match obj:
        case Hashable():
            print('Hashable type:  ', type(obj))
        case _:
            print('Unhashable type:', type(obj))

This produces the desired answer:

Unhashable type: <class 'list'>
Hashable type:   <class 'tuple'>
Unhashable type: <class 'set'>
Hashable type:   <class 'frozenset'>
Hashable type:   <class 'int'>
Hashable type:   <class 'NoneType'>
Unhashable type: <class 'dict'>

Calls to hash() may still fail or be useless

Hashable only deals with the type of the outermost object. It reports hashability in the sense of "the object's type implements hashing" which is what we usually mean when we say "tuples are hashable". That is also the same sense that is used by abstract base classes and by static typing.

Though Hashable detects whether a type implements _hash_, it can not know what hashing actually does, whether it will succeed, or whether it will give consistent results.

For example, hashing gives inconsistent results for float('NaN'). Tuples and frozensets are normally hashable but will fail to hash if their components values are unhashable. A class could define __hash__ to always raise an exception.

Raymond Hettinger's answer works in limited cases, but it fails on inputs like list (the type object itself), which is hashable even though list.__hash__ is None, and inputs like ([1, 2], [3, 4]), which is unhashable even though tuple.__hash__ is not None.

The most reliable way to detect whether an object is hashable is always going to be to try to hash it. If you want to do that in a match statement, the easiest way would be to write a guard:

def hashable(x):
    try:
        hash(x)
    except TypeError:
        return False
    else:
        return True

match x:
    case _ if hashable(x):
        ...
    ...

This just directly calls hash(x) and sees whether it works, instead of trying to perform a structural check.

If you need the hash and want to avoid double-computation, you can save the hash(x) result:

def try_hash(x):
    try:
        return hash(x)
    except TypeError:
        return None

match x:
    case _ if (x_hash := try_hash(x)) is not None:
        ...
    ...