Type not narrowed correctly in else branches?

[crides]

For the following code:

from typing import cast, assert_type

a = cast(list[int] | int, 3)
if type(a) == list:
    assert_type(a, list[int])
else:
    assert_type(a, int)

Somehow pyright can infer that a is indeed list[int] in the true branch, but in the else branch a is inferred as list[int] | int still. Is this expected behavior?

[erictraut]

Yes, this is expected behavior. It's unsafe to narrow the type in the negative (else) case because you're using the type(a) == x type guard instead of isinstance(a, x). This example shows why this is unsafe:

def func(a: list[int] | int):
    if type(a) == list:
        print("Got a list!")
    else:
        print("Got an int?")

class MyList(list[int]):
    ...

func(MyList()) # Prints "Got an int?"

Not surprisingly, mypy produces the same type narrowing results as pyright in this case.

[crides]

Ah, because type(...) == ... checks for the "current" type, not the "tree" of subtypes.

By the way, is there a way to check if a is actually list[int] (or any subclass of it)?

[erictraut]

By the way, is there a way to check if a is actually list[int] (or any subclass of it)?

def is_list_of_ints(val: object) -> TypeGuard[list[int]]:
    return isinstance(val, list) and all(isinstance(x, int) for x in val)

[crides]

I see. Much thanks for the speedy answers!

[paulzzy]

Apologies for reviving a necrothread, but here's a method that works for type variables (like type[Foo]). For some reason isinstance doesn't work (I get errors talking about <subclass of type Foo and Bar>).

def is_type_foo(type_) -> TypeGuard[type[Foo]]:
    return type_ is Foo or issubclass(type_, Foo)