Why did PEP589 decide to make TypedDict inconsistent with dict?

[randolf-scholz]

I never really used TypedDicts before, but when I tried it, I immediately stumbled over the following:

class MyDict(TypedDict):
      x: int
      y: int
      z: int

def foo(d: dict[str, int]) -> None:
     ....

mydict: MyDict = {"x" : 0, "y": 1, "z": 2}
foo(mydict)  # typing error!

Trying to understand why, the PEP states:

A TypedDict isn’t consistent with any Dict[...] type, since dictionary types allow destructive operations, including clear(). They also allow arbitrary keys to be set, which would compromise type safety. Example:

class A(TypedDict):
    x: int

class B(A):
    y: str

def f(d: Dict[str, int]) -> None:
    d['y'] = 0

def g(a: A) -> None:
    f(a)  # Type check error: 'A' incompatible with Dict[str, int]

b: B = {'x': 0, 'y': 'foo'}
g(b)
b['y'] + 'bar'  # Runtime error: int + str

But, this example makes no sense! The typing error should occur when calling g(b), because dict[str, int | str] is incompatible with dict[str, int] (and class B isn't even a dict!), as MutableMappings are invariant in both keys and values.

---

It seems the real issue here is mutability, not that dict is incompatible with TypedDict. It seems like a waste not being able to feed a TypedDict into a pure function that accepts dict.

[JelleZijlstra]

The typing error should occur when calling g(b), because dict[str, int | str] is incompatible with dict[str, int] (and class B isn't even a dict!)

g accepts an argument of type A and we're passing a B. B and A are both TypedDicts and B is a subclass of A, so the call is fine.

[randolf-scholz]

nvm feel free to delete this post