Should `callable` narrow to `TypeIs[Callable[..., object]]` or `TypeIs[Callable]` ?

Currently, typeshed annotates

def callable(obj: object, /) -> TypeIs[Callable[..., object]]: ...

However, for the majority of type checkers this creates discrepancy between collections.abc.Callable and builtins.callable narrowing, only ty seems to consider blank Callable as if it were Callable[..., object], whereas all other type checkers treat it as Callable[..., Any].

from typing import reveal_type, TypeIs
from collections.abc import Callable

def is_callable(arg: object) -> TypeIs[Callable]:
    raise NotImplementedError

def check_callable(arg: object) -> None:
    if isinstance(arg, Callable):
        reveal_type(arg)
            
def check_callable2(arg: object) -> None:
    if callable(arg):
        reveal_type(arg)
        
def check_callable3(arg: object) -> None:
    if is_callable(arg):
        reveal_type(arg)

Bắt đầu với annotation builtins.callable và so sánh nó với collections.abc.Callable. Chạy các ví dụ dựa trên các hành vi của type-checker được liệt kê trong issue, sau đó xem lại phần thảo luận trong các bình luận để xác định annotation nào cung cấp narrowing nhất quán; được xem là hoàn tất khi stub được chọn khớp với hành vi mong muốn trên tất cả các checker bị ảnh hưởng.