A generic type argument accepts a tuple

[hyperkai]

*Memo:

• mypy test.py
• mypy 1.19.1
• Python 3.14.0

A generic type argument accepts a tuple as shown below:

       # ↓↓
v1: list[()]
v1 = [0, 1, 2]       # No error
v1 = ['A', 'B', 'C'] # No error

       # ↓↓↓↓↓↓
v2: list[(int,)]
v2 = [0, 1, 2]       # No error
v2 = ['A', 'B', 'C'] # Error

       # ↓↓↓↓↓↓
v3: list[(str,)]
v3 = [0, 1, 2]       # Error
v3 = ['A', 'B', 'C'] # No error

        # ↓↓↓↓↓↓↓↓↓↓
v1: tuple[(int, ...)]
v1 = (0, 1, 2)       # No error
v1 = ('A', 'B', 'C') # Error

        # ↓↓↓↓↓↓↓↓↓↓
v2: tuple[(str, ...)]
v2 = (0, 1, 2)       # Error
v2 = ('A', 'B', 'C') # No error

[A5rocks]

This is actually how you are able to type empty generics! This is intentional, because slicing turns the X[int, str] to be equivalent to X[(int, str)].

[A5rocks]

Oops, just noticed list[()] is accepted? That's a bug

[sterliakov]

tuple behavior is correct, tuple[(str, ...)] and tuple[str, ...] are exactly equivalent and even parse to the same AST, so mypy shouldn't report that. It's also correct to write, for example, Mapping[(str, str)] - it's the same as Mapping[str, str] on the AST level.

So only single-arg generics like list are subject to this question. I'd say that list[(str,)] should be allowed for consistency with all other generics, although list[str] does not have a tuple in ast and this variation does. Single-arg generics are not special semantically.

If we allow that, by extrapolation list[()] becomes equivalent to plain unparameterized list, and the omitted generic param is filled with Any - this is what mypy does now (check your snippet with --strict, we even report type-arg for missing args). Multi-args versions like list[(str, str)] are already rejected (because, again, mypy starts from AST level and so can't distinguish that from list[str, str], and we have checks for extra/missing generic params). So mypy behavior is consistent now, and TBH I'm not convinced that changing this is worth the hassle. list[(str,)] is weird, but unambiguous and safe - it might be better as a linter rule.

Just as a reminder, it's the comma what makes a tuple, not the parens, so a, b and (a, b) are equivalent in most contexts, including type param list.

[A5rocks]

the omitted generic param is filled with Any - this is what mypy does now

Ok, that makes more sense. I still think it should error, just like if I left off a generic arg (for a two arg generic X, I think X[int] fails for non-strict?) or added an extra.

I think list[(str,)] is ok.

[sterliakov]

I still think it should error

it does under --strict:

foo: list[()]  # E: Missing type arguments for generic type "list"  [type-arg]
reveal_type(foo)  # N: Revealed type is "builtins.list[Any]"

[A5rocks]

Without --strict! Just like how dict[int] errors.

[hauntsaninja]

Btw, @hyperkai just wanted to say thank you for testing all the type checkers against the cases you've been digging up. Helps make the ecosystem more consistent and robust :-)