Better binding with implicit type variables

[randolf-scholz]

Code sample in mypy playground

type Pair[T] = tuple[T, T]

class Foo[P: Pair]:
    def __init__(self, pair: P) -> None:
        self.pair: P = pair

foo = Foo((1, "a"))
reveal_type(foo)  # Foo[tuple[int, str]] ❌
reveal_type(foo.pair)  # tuple[int, str] ❌

In the example above, P gets bound to tuple[L[1], L["a"]], but this does not look like a Pair! My expectation was to get something like Foo[tuple[int | str, int | str]] or Foo[tuple[object, object]] or an arg-type error.

Indeed, we can get this inference if we put in some extra work: Code sample in mypy playground

class Bar[P: Pair]:
    def __init__[S](self: "Bar[Pair[S]]", pair: tuple[S, S]) -> None:
        self.pair: P = pair

bar = Bar((1, "a"))
reveal_type(bar)  # Bar[tuple[object, object]] ✅
reveal_type(bar.pair)  # tuple[object, object] ✅

[A5rocks]

The T in the __init__ and the T in Pair are different variables by the way (I haven't fully parsed the initial fragment of code though)

[A5rocks]

I think the problem here is that you are leaving out the type parameters for Pair (you can see this erroring with --strict) which means they (or well, it, since there's only one) get filled with Any. I suppose this loses track of any relationship within the tuple? That seems like a bug.

For reference, here's a snippet that displays behavior that feels (! I'm not sure) buggy to me:

from typing import Any
from dataclasses import dataclass

type Pair[T] = tuple[T, T]

# @dataclass
# class Pair[T]:
#     first: T
#     second: T

class Foo[P: Pair[Any]]:
    def __init__(self, pair: P) -> None:
        self.pair: P = pair

x = Foo(("a", 5))
reveal_type(x)

def takes_pair[T](x: Pair[T]) -> T:
    return x[0]

reveal_type(x.pair)
reveal_type(takes_pair(x.pair))

Replace the tuple with the dataclass to see what I think is correct behavior (though it adds an extra inference step which solves the problem so it's not an obvious "we forgot to implement this for tuples")

[erictraut]

For visibility, here's a link to the same bug report filed in the pyright issue tracker.

[A5rocks]

Interesting, I was thinking that even though at some level the type might be tuple[Any, Any], I'm not sure it should be considered as such? I know we defer type aliases (though I forgot why) so this is also trying to infer tuple[str, int] against Pair[Any] so... maybe mypy can do better here?

I wish there was a label so I could show I'm unsure about my triage! (I added the question label as a best proxy...)

[randolf-scholz]

The T in the __init__ and the T in Pair are dif

Oops, it was there by accident. I updated the OP.