Unfortunately, that doesn't provide the desired affect. That only works if the type checker already knows the type of the parameter matches `Tuple[_T, _T]` because it's going to be matching the call to the overload that works (versus we need to pick how to narrow the type at the call site based on the return value). Take this full example: ``` from typing import Literal, Tuple, TypeVar, overload _T = TypeVar("_T") @overload def is_two_element_tuple(val: Tuple[_T, _T]) -> Literal[True]: ... @overload def is_two_element_tuple(val: Tuple[_T, ...]) -> bool: ... def is_two_element_tuple(val): return len(val) == 2 def print_coord(c: Tuple[int, ...]): if is_two_element_tuple(c): reveal_type(c) # Should be Tuple[int, int] x, y = c print(f"x={x}, y={y}") else: reveal_type(c) # Should be Tuple[int, ...] print("I dunno.") ``` In this case, the code is intending to have the check verify that the tuple has two elements for some arbitrary tuple. We don't know that c has two elements until we do the check. mypy says: main.py:16: note: Revealed type is 'builtins.tuple[builtins.int]' main.py:20: note: Revealed type is 'builtins.tuple[builtins.int]' pyright says: 16:21 - warning: Type of "c" is "Tuple[int, ...]" 20:21 - warning: Type of "c" is "Tuple[int, ...]" Compare that to the original example: ``` def is_two_element_tuple(val: Tuple[_T, ...]) -> TypeGuard[Tuple[_T, _T]]: return TypeGuard(len(val) == 2) ``` Here, the input is the generic type ("I will prove something about a value of this type"), and the output is the specific one ("I will either tell you True if it's of type Tuple[_T, _T] or False otherwise").