(I'm gonna be really surprised if anybody is out here unpacking zero-length iterables, though.)

To my surprise, this works:

() = []

To my surprise, this works:

() = []

...for some definition of "works". The whole thing gets peepholed out. ;)

I think maybe once long ago I used something like this to "assert" that an iterator I used was completely exhausted (the idea being that it would raise a TypeError if not):

it = iter(something)

# ...do some stuff...

[] = it  # Fails if there are any remaining items.

I thought it was pretty clever at the time. :)

UNPACK_SEQUENCE 0 does occur. In this:

def f(x):
    match x:
        case T():
            pass

  1           0 RESUME                   0

  2           2 LOAD_FAST                0 (x)

  3           4 LOAD_GLOBAL              0 (T)
              6 LOAD_CONST               1 (())
              8 MATCH_CLASS              0
             10 COPY                     1
             12 POP_JUMP_IF_NONE        10 (to 20)
             14 UNPACK_SEQUENCE          0

  4          16 LOAD_CONST               0 (None)
             18 RETURN_VALUE

  3     >>   20 POP_TOP
             22 LOAD_CONST               0 (None)
             24 RETURN_VALUE

UNPACK_SEQUENCE 0 does occur.

Interesting. That's a common case that's worth improving.