How/why does set() in {frozenset()} work?

Question

Even though sets are unhashable, membership check in other set works:

>>> set() in {frozenset()}
True

I expected TypeError:

Answer 1

set_contains is implemented like this:

static int
set_contains(PySetObject *so, PyObject *key)
{
    PyObject *tmpkey;
    int rv;

    rv = set_contains_key(so, key);
    if (rv < 0) {
        if (!PySet_Check(key) || !PyErr_ExceptionMatches(PyExc_TypeError))
            return -1;
        PyErr_Clear();
        tmpkey = make_new_set(&PyFrozenSet_Type, key);
        if (tmpkey == NULL)
            return -1;
        rv = set_contains_key(so, tmpkey);
        Py_DECREF(tmpkey);
    }
    return rv;
}

So this will delegate directly to set_contains_key which will essentially hash the object and then look up the element using its hash.

If the object is unhashable, set_contains_key returns -1, so we get inside that if. Here, we check explicitly whether the passed key object is a set (or an instance of a set subtype) and whether we previously got a type error. This would suggest that we tried a containment check with a set but that failed because it is unhashable.

In that exact situation, we now create a new frozenset from that set and attempt the containment check using set_contains_key again. And since frozensets are properly hashable, we are able to find our result that way.

This explains why the following examples will work properly even though the set itself is not hashable:

>>> set() in {frozenset()}
True
>>> set(('a')) in { frozenset(('a')) }
True

Answer 2

The last line of the documentation for sets discusses this:

Note, the elem argument to the __contains__(), remove(), and discard() methods may be a set. To support searching for an equivalent frozenset, a temporary one is created from elem.