Example:

```
from typing import MutableSequence, TypeVar

CliffordGate = TypeVar('CliffordGate')

class QCircuit(MutableSequence[CliffordGate]):
    def __init__(self, gates):
        self.gates = list(gates)

    def __repr__(self):
        return f'{self.__class__.__name__}({self.gates})'
   
    def __getitem__(self, key):
        return self.gates[key]

    def __setitem__(self, key, item):
        self.gates[key] = item

    def __delitem__(self, key):
        del self.gates[key]

    def insert(self, key, item):
        self.gates.insert(key, item)

a = QCircuit(['H0', 'S2'])
a += a
```

I forgot to copy over __len__ in the example

It would be reasonable to add special handling for this case to match what is done in the concrete sequences like list, deque, bytes, ...

deque and bytearray make an in-memory copy of self if extended with self. deque creates a temporary list, bytearray creates a temporary bytearray. list just iterates itself as a linear array of known size and avoids infinite loop. It could be possible to avoid creaing a temporary copy in case of deque and bytearray too, but I don't think this special case is worth an additional code.

But a MutableSequence can represents a sequence that doesn't fit in memory. It can provide an interface to a linear on-disk store. In this case creating an on-memory copy is not possible.

> But a MutableSequence can represents a sequence that doesn't
> fit in memory. It can provide an interface to a linear 
> on-disk store. In this case creating an on-memory copy 
> is not possible.

This case is likely not worth worrying about.  If a user created such a sequence AND wrote "s += s", it is unclear whether any particular unpleasant outcome (including the current behavior) could be avoided.

Agreed. Appending >2**31 items one by one to the collection with external storage is not very efficient, so such collection likely has specialized extend().

New changeset 1b5f9c9653f348b0aa8b7ca39f8a9361150f7dfc by Raymond Hettinger (Naris R) in branch 'master':
bpo-34427: Fix infinite loop when calling MutableSequence.extend() on self (GH-8813)
https://github.com/python/cpython/commit/1b5f9c9653f348b0aa8b7ca39f8a9361150f7dfc

Thank you for the patch.