Make abstract/dunder methods positional-only.

Feature or enhancement

It would be nice if certain abstract methods / dunder methods would be defined with positional-only arguments, so that when one subclasses them an appropriate name can be chosen, or they can be defined positional-only in the subclass.[^1]

Code sample in pyright playground[^1]

from typing import overload
from collections.abc import Sequence

class MySequence[T](Sequence[T]):
    def __len__(self): return 0
    @overload
    def __getitem__(self, idx: int, /) -> T: ...
    @overload
    def __getitem__(self, idx: slice, /) -> Sequence[T]: ...
    def __getitem__(self, idx: int | slice, /) -> T | Sequence[T]:  # ❌ override
        return MySequence[T]()

In some cases, the stubs already fake that the argument is positional-only, such as for Container.__contains__:

• def __contains__(self, x: object, /) -> bool: ... in typeshed/stdlib/typing.pyi
• def __contains__(self, x): in cpython/Lib/_collections_abc.py

Personally, I think only changing the stubs would be a pragmatic choice, but I was told by the maintainers that they believe this change should be done in Cpython first.

Backward Compatibility

1. Changing non-abstract methods can potentially break user code. For example, this is currently legal code at runtime

   from collections.abc import Container.
   Container.__subclasshook__(C=list)  # True
   

2. Changing the signature of abstract methods can introduce type-checker errors Code sample in pyright playground[^1]

   from collections.abc import Sequence
   def get(x: Sequence[float], index: int) -> float:
       return x.__getitem__(index=index)
   

With this in mind, I believe changing abstrac dunder methods to use positional only arguments should be relatively safe, as calling them directly with keyword is very uncommon, and at worst it will introduce type errors.

Personally, I'd also like so see methods like Container.__subclasshook__ use positional-only arguments, but I also understand if this is not feasible due to bc-conerns.

[^1]: Note that mypy special cases certain dunder methods, and yields different results than pyright on these examples

Has this already been discussed elsewhere?

https://github.com/python/typeshed/issues/14071

Linked PRs

• gh-136324

Start with the cited definitions in Lib/_collections_abc.py and typeshed/stdlib/typing.pyi, then review linked PR gh-136324 and the related typeshed issue. Done means the agreed abstract and dunder method signatures are updated in CPython while the documented backward-compatibility concerns are addressed.