How to make an unspecialized generic default to Any in strict mode?

[Graham Preston (grahamcracker1234)]

I’m trying to figure out how to tell pyright (in strict mode) that a bare instantiation of a generic class should resolve to Foo[Any] rather than a partially unknown `Foo[Unknown].

Here’s the minimal scenario:

from typing import Any


class Foo[T]:
    bar: T


def match(obj: Any) -> Foo[Any] | None:
    match obj:
        case Foo() as foo:  # Error: Type of "foo" is partially unknown
            return foo  # Error: Return type, "Foo[Unknown]", is partially unknown
        case _:
            return

In strict mode, pyright reports that foo is of type Foo[Unknown] rather than resolving it to Foo[Any].

What I would like

I would like pyright to interpret a bare pattern match on Foo() as meaning Foo[Any]. That is, if type parameters cannot be inferred during pattern matching, default them to Any rather than leaving them as partially unknown.

I tried adding type constraints and a default type to the generic type in the Foo class, but it doesn't seem to do anything.

class Foo[T: Any = Any]:
    bar: T

Ideally whatever strategy is used here could also be used for built-in collection types and collections.abc.

def match(obj: Any) -> list[Any] | None:
    match obj:
        case list() as lst:  # Error: Type of "lst" is partially unknown
            return lst  # Error: Return type, "list[Unknown]", is partially unknown
        case Sequence() as seq:  # Error: Type of "seq" is partially unknown
            return list(seq)  # Error: Argument type is partially unknown
        case _:
            return

Questions

1. Is there any supported way in pyright strict mode to make unspecialized generics default to Any?

2. Is there a configuration option, typing trick, or pattern-match protocol hook that ensures that a bare Foo() match results in a concrete Foo[Any] instead of a partially‑inferred generic?

3. If the answer is “no, pyright intentionally preserves unspecialized generic parameters,” why is that? And what is the recommended idiom? For example:

def match(obj: Any) -> Foo[Any] | None:
    match obj:
        case Foo() as foo:  # This line still errors and would be need to be specifically ignored
            return cast(Foo[Any], foo)
        case _:
            return

…but I’m wondering whether pyright has an officially encouraged way of handling pattern‑matching with generic types when the type parameter cannot be inferred.

[Ammann Labs (agammann)]

If you want to deliberately treat the contents of any Foo as Any, you can state that through a TypeGuard. A guarded wildcard case avoids first capturing a Foo[Unknown] in a Foo() class pattern:

from typing import Any, Generic, TypeGuard, TypeVar

T = TypeVar("T")


class Foo(Generic[T]):
    def __init__(self, bar: T):
        self.bar = bar


def is_foo(value: object) -> TypeGuard[Foo[Any]]:
    return isinstance(value, Foo)


def match_foo(obj: Any) -> Foo[Any] | None:
    match obj:
        case _ if is_foo(obj):
            return obj
        case _:
            return None


assert match_foo(Foo(3)) is not None
assert match_foo("not a Foo") is None

I checked this with Pyright 1.1.414 in strict mode and Python 3.12.14. It produces no partially-unknown diagnostics and returns the original Foo instance. The Generic[T] spelling here can be replaced by your Python 3.12 class Foo[T] declaration.

This is an explicit decision to erase the element type, so it doesn't establish that bar has any particular type. The same approach can declare TypeGuard[list[Any]] or TypeGuard[Sequence[Any]] when that is the boundary you intend. Pyright documents user-defined guards among its supported narrowing expressions.

[Graham Preston (grahamcracker1234)]

This seems like a good workaround for the time being. I say a workaround and not an solution because it seems to me like a bug/oversight to still have the error at all when you add a type constraint and/or default:

class Foo[T: Any = Any]:
    bar: T