Error in `TypedDict` assignability rule

[Viicos]

The spec says:

First, any TypedDict type is assignable to Mapping[str, object].

Second, a TypedDict type B is assignable to a TypedDict A if and only if both of these conditions are satisfied:

• For each key in A, B has the corresponding key and the corresponding value type in B is consistent with the value type in A.

• For each required key in B, the corresponding key is required in A. For each non-required key in B, the corresponding key is not required in A.

However, the following seems to be accepted by type checkers:

from typing import TypedDict


class A(TypedDict):
    a: int

class B(TypedDict):
    a: int
    b: str

def func(a: A): pass

b: B = ...
func(b)  # OK

However, following the second point, any required key in B should be required in A. Or, b is required in B but not required (because not defined) in A.

@JelleZijlstra suggested that the second bullet point should be updated to:

For each required key in A, the corresponding key is required in B. For each non-required key in A, the corresponding key is not required in B.

Should we also say something about extra keys are allowed to be present in B?

[erictraut]

Thanks for pointing this out.

This was due to a clerical error. At some point, someone did a pass through the typing spec and changed all of the assignability rules to assign B to A rather than the other way around. The symbol names shouldn't matter in assignability rules, but it's useful to be consistent throughout the document, so the update was welcomed. It appears that the first bullet was updated in this pass but the second was not. You can see this was the case when you compare the current typing spec with the language in the original PEP. So I agree with Jelle that the second bullet point should be updated such that A and B are swapped.

I don't think there's a need to say anything about extra keys. That's implied by the current rules, and adding additional (unnecessary) rules could make the spec less clear.

[Viicos]

I don't think there's a need to say anything about extra keys. That's implied by the current rules, and adding additional (unnecessary) rules could make the spec less clear.

PEP 728 will probably update it anyway. I pushed a fix in #1974.

[Viicos]

I just have one more question related to the behavior of type checkers:

In the example in my OP, b (annotated as B) is assignable to A. However, if I assign a dict value directly to A, I get a type checker error:

class A(TypedDict):
    a: int

a: A = {'a': 1, 'extra': 'test'}  # error

My understanding is that either:

• assignability doens't apply here, as it is a concept that involves two types.
• assignability applies, but type checkers special case such assignments and error even if extra keys may be present.

Do you happen to know which one it is?

[JelleZijlstra]

I believe this is a special case. I can't find where in the spec we mandate this, though. The idea is that if you use a dict literal, an extra key may well contain a typo.

[brianschubert]

The construction special case is described here:

Extra keys included in TypedDict object construction should also be caught.