Exclude types from generic that cannot be "reached"?

[Holt59]

I'm putting this here but maybe that could go into the typing repository.

Consider the following snippet:

from typing import TypeGuard

def is_empty_tuple[_K, *_KS](k: tuple[()] | tuple[_K, *_KS]) -> TypeGuard[tuple[()]]:
    return len(k) == 0


def extract[_K, *_KS](k: _K | tuple[()] | tuple[_K, *_KS]) -> _K:
    if isinstance(k, tuple):
        if is_empty_tuple(k):
            raise ValueError()
        return k[0]
    else:
        return k

My goal here is to "exclude" tuple from _K (which is currently not supported by Python). From my point-of-view, tuple[()] | tuple[_K, *_KS] covers every possible tuple, so I would think that _K would be deduced as "not a tuple".

I understand this is currently not the case (or maybe I'm missing something), so

• Is there something I'm missing as to why _K could not be deduced as "not a tuple"?
• Could this be implemented in pyright without changes to Python typing itself?

[erictraut]

Pyright is implementing TypeGuard correctly. It does not allow for narrowing in the negative ("else") case.

What you're looking for here is TypeIs, which was introduced in PEP 742.

[Holt59]

Thanks for the answer. Switching to TypeIs does not really fix the problem because the main problem is in the positive case (I tried to create a minimal example but in the end I added some noisy stuff that made the question unclear... ).

My point is that tuple[()] | tuple[_K, *_KS] covers all possible tuple types, so within the if, k should be tuple[()] | tuple[_K, *_KS], but it's actually tuple[()] | tuple[_K, *_KS] | tuple[Unknown, ...]* (since _K could be tuple[Unknown, ...] in a sense).

My question was whether or not a more intelligent "type narrowing" could be implemented in pyright? And if so, would that conflict with Python typing specification (e.g., require a PEP to allow such type narrowing)?

I understand that even if it would be possible, it could be very complicated (and thus most likely ignored), but I'm mostly curious.

Here is a simpler case

def foo[_K, *_KS](k: _K | tuple[*_KS]) -> _K | tuple[*_KS]:
    if isinstance(k, tuple):
        return k  # here k is "tuple[Unknown, ...]* | tuple[*_KS@foo]" but it 'should' be tuple[*_KS@foo]
    else:
        return k

This could also apply to overloaded function, where the narrower overload would match instead of the generic one.

[erictraut]

In your example, _K could be a tuple, so it's not safe for a type checker to eliminate _K as part of isinstance narrowing. Generally, it's possible for _K to capture a tuple because there may be other constraints on _KS that prevent tuple[*_KS] from capturing a tuple input. Even in your simple example where there are no other apparent constraints on _KS (since it doesn't appear multiple times in the input signature), there are ways that you could end up with _K capturing a tuple. One way is with explicitly-specializable (subscriptable) functions, as proposed in draft PEP 718. If _K and _KS were class-scoped type variables, they could be explicitly specialized without PEP 718.

class Foo[_K, *_KS]:
    def method(self, k: _K | tuple[*_KS]) -> _K | tuple[*_KS]:
        ...

f = Foo[tuple[int, str], str]  # _K = tuple[int, str] in this case

Even without explicit specialization, it's possible through partial specialization (e.g. by using a decorator).

def deco[T](f: Callable[[T | tuple[str, ...]], T]) -> Callable[[T], T]:
    return f

bar = deco(foo)

def func(x: tuple[int, str]):
    reveal_type(bar(x)) # tuple[int, str] | tuple[str, ...]

[Holt59]

Thanks for the explanation, that's unfortunate, I guess I'll just have to wait for some kind of "negative type bounds" to be proposed and implemented.