I am not sure I like this change and I am unsure why pyre would like to introduce this arbitrary restriction. I find Callable[[_F], _F] more readable and convenient than introducing a new name by using a callback protocol. I am -1 on this change.

(Also, per our conventions, this would need to be called _IdentityFunction as it doesn't exist at runtime.)

As this is quite a significant change, I think it's best discussed at typing-sig.

I am unsure why pyre would like to introduce this arbitrary restriction.

This isn't quite introducing a new restriction as much as codifying our pre-existing lack of support for a MyPy-specific special case. Pyre has always interpreted all free type variables in a def or class as being in the scope of that define/class. MyPy also does this in most circumstances with Callable[[T], T], as both checkers have identical interpretations of

T = TypeVar("T")
def f(x: T) -> Callable[[T], T]: ... # def <T> (T) -> Callable[[T], T]
# and
def f(f: Callable[[T], T]) -> T: ... # def <T> (Callable[[T], T]) -> T
#and
def i() -> Tuple[Callable[[T], T], T]: ...  # def <T>  () -> Tuple[Callable[[T], T], T]: ... 
# and
class Child(Base[Callable[[T], T]]): ... # class <T> Child(Base[Callable[[T], T]])

Pyre and MyPy only differ here in that MyPy introduces a unique special case that alters the behavior for free variables:

• inside a Callable type
• in the return type of a def
• not present in any parameter of the def
• not present anywhere else in the return type that isn't also inside of a Callable type.

I can definitely see how this special case is helpful in making definitions for decorator factories more compact, but for us the inconsistency of this behavior from a user's perspective outweighs the concision.

Happy to forward this discussion onto typing-sig if you think it would be helpful.

@srittau checking back in: do you still think that this needs to be discussed on typing-sig, or are you satisfied with the explanation above?

@mrkmndz Sorry for forgetting to answer. Yes, considering theconsequences this has for the typing infrastructure, I think this should be discussed on typing-sig.

OK, moving this discussion to
https://mail.python.org/archives/list/typing-sig@python.org/thread/DDR2B3USYCQGVXM3ZSK2FASH5YFQGPUV/

Hi @srittau , would you mind responding to @dkgi 's question of you on typing-sig?

I think we're both still a bit confused as to what precisely is blocking this PR.

Thanks!

I am honestly not sure what else there is to add. So far, Callable[[_T], _T] is a construct that's accepted by typeshed. There seemed to be no support for changing this outside of the pyre team. I am opposed to replacing this construct with protocols all over typeshed, although I could live with a central IdentityFunction (or similar) alias in _typeshed. I'd be interested what the other typeshed maintainers think.

I just replied on the email thread; I think we should go ahead with this change.