Difference between operator and dunder call

[Robbe Pincket (Kroppeb)]

Given the following code, I'm a bit confused as to why there is a difference between using the operator >> or using the function call __rshift__.

Playground

from typing import Callable, reveal_type


class Foo[T]():
    def __covariant(self) -> T:
        ...
    
    def __rshift__[R](self, other: "Callable[[Foo[T]], Foo[R]]") -> "Foo[R]":
        return other(self)
    
def foo_map[T, R](
        mapper: Callable[[T], R]
) -> Callable[[Foo[T]], Foo[R]]:
    def map_func(foo: Foo[T]) -> Foo[R]:
        raise NotImplementedError
    return map_func

p = Foo[str]()

r1a = reveal_type(p >> foo_map(lambda x: x))  # type is Foo[Unknown]
r2a = reveal_type(p >> foo_map(lambda x: (x, 15)))  # type is Foo[tuple[T@foo_map, Literal[15]]]
r3a = reveal_type(p >> foo_map(lambda x: x + "!"))  # type error: Operator "+" not supported for types "T@foo_map" and "Literal['!']", type is Foo[Unknown]

r1b = reveal_type(p.__rshift__(foo_map(lambda x: x)))  # type is Foo[str]
r2b = reveal_type(p.__rshift__(foo_map(lambda x: (x, 15))))  # type is Foo[tuple[str, Literal[15]]]
r3b = reveal_type(p.__rshift__(foo_map(lambda x: x + "!")))  # type is Foo[str]  (no error)

[Eric Traut (erictraut)]

This behavior is expected. The >> operator is not the same as __rshift__. The >> operator potentially involves a series of calls including __rshift__ and __rrshift__. Pyright must simulate this runtime behavior, and to do so, it needs to evaluate the types of the LHS and RHS operands without the benefit of bidirectional type inference. It then needs to use these types to evaluate both LHS.__rshift__(RHS) and RHS.__rrshift__(LHS) to determine whether one of them is supported. By contrast, if you directly call __rshift__, pyright is able to employ bidirectional type inference.

Bidirectional type inference is required for precise evaluation of lambda expressions.