How can I properly check if a collections.abc class is empty?

When starting out in Python we're all told that this is how you check if a sequence (list, tuple, set, dict, etc.) is empty:

if not cookies:
    print("The cookie monster needs his cookies")

and not like this:

if not len(cookies):
    print("This is bad")
if cookies == []:
    print("This is just wrong")

Once we learn some more Python we might learn that it's good to write code that caters to interfaces from collections.abc instead of assuming the built-in collections like list, dict, set, tuple, etc. Now we might think it's proper to write a function like this one:

def eat(cookies: Sequence[Cookie]):
    if not cookies:
        raise ValueError("The cookie monster needs his cookies")
    print("Yum yum")

or even something like this, which is actually wrong because generators for example always give bool(gen) == True:

def eat(cookies: Iterable[Cookie]):
    if not cookies:
        raise ValueError("The cookie monster needs his cookies")
    print("Yum yum")

cookies = (ChocoChipCookie(), OatmealCookie(), PeanutButterCookie(), SugarCookie())

eat(c for c in cookies if isinstance(c, RasinCookie)) # Wrongly prints "Yum yum"
eat([c for c in cookies if isinstance(c, RasinCookie)]) # Correctly raises ValueError

I'd always assumed that some interface in collections.abc defined __bool__ or even inferred it from __len__ but I noticed today that bool is not even mentioned in collections.abc's documentation, not even for the most complete ones like Sequence even though it could easily be provided by Sized which defines __len__.

The absence of __bool__ makes even the first implementation of eat() wrong, since there's no guarantee that a subclass of Sequence implements __bool__ and has it behave like we'd expect.

What's the correct way to check emptiness of all the different collections in collections.abc, if any, and why don't they (at least some of them) define __bool__?

The idea of checking for "emptiness" simply does not make sense for many of the classes defined in collections.abc. In particular, the example you give in the question, the Iterable class, can only be checked for emptiness when an actual attempt to consume an item from it is made--if it turns out to be empty, great, but if it is not, then oops, too bad, the mere attempt to check for emptiness will have irreversibly altered the state of the iterable/iterator/generator. This is why the __bool__ method is implemented only in classes where it makes sense.

After playing around with some custom collections and looking at some more documentation, I realised that the bool() documentation covers this:

> By default, an object is considered true unless its class defines either a __bool__() method that returns False or a __len__() method that returns zero, when called with the object.