利用Protocol为可排序且可哈希的参数创建精确类型提示

from collections.abc import Hashable
from typing import TypeVar

# 这种方式只表达了可哈希性
OrderedHashable = TypeVar('OrderedHashable', bound=Hashable)

def foo(bar: OrderedHashable) -> None:
    # 在这里，我们知道bar是可哈希的，但静态分析工具不知道它是否可排序
    pass

from typing import Hashable, Protocol, TypeVar

# 定义一个Protocol，表示既是可哈希的，又支持排序比较
class OrderedHashable(Hashable, Protocol):
    """
    表示一个既可哈希又可排序的类型。
    需要实现__hash__、__eq__（来自Hashable）以及__gt__、__lt__方法。
    """
    def __gt__(self, other: "OrderedHashable") -> bool:
        """
        定义大于操作 (self > other)。
        """
        ... # 省略具体实现，Protocol中只需声明签名

    def __lt__(self, other: "OrderedHashable") -> bool:
        """
        定义小于操作 (self < other)。
        """
        ... # 省略具体实现，Protocol中只需声明签名

# 使用TypeVar绑定这个Protocol，以便在泛型函数中使用
OrderedHashableT = TypeVar('OrderedHashableT', bound=OrderedHashable)

def process_ordered_hashable(item: OrderedHashableT) -> None:
    """
    一个接受可排序且可哈希参数的函数。
    """
    print(f"处理项: {item}")
    # 静态类型检查工具现在知道item支持哈希和比较操作
    _ = hash(item) # 可哈希
    if item < item: # 可排序
        pass
    if item > item: # 可排序
        pass

# 示例：定义一个符合OrderedHashable协议的类
class MySortableItem:
    def __init__(self, value: int, name: str):
        self.value = value
        self.name = name

    def __hash__(self) -> int:
        return hash((self.value, self.name))

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, MySortableItem):
            return NotImplemented
        return self.value == other.value and self.name == other.name

    def __lt__(self, other: "MySortableItem") -> bool:
        if not isinstance(other, MySortableItem):
            return NotImplemented
        return self.value < other.value

    def __gt__(self, other: "MySortableItem") -> bool:
        if not isinstance(other, MySortableItem):
            return NotImplemented
        return self.value > other.value

    def __repr__(self) -> str:
        return f"MySortableItem(value={self.value}, name='{self.name}')"

# 使用示例
item1 = MySortableItem(10, "Apple")
item2 = MySortableItem(20, "Banana")

process_ordered_hashable(item1) # 类型检查通过
process_ordered_hashable(item2) # 类型检查通过

# 尝试使用不符合协议的类型（例如，只可哈希但不可排序）
class JustHashable:
    def __init__(self, value: int):
        self.value = value
    def __hash__(self) -> int:
        return hash(self.value)
    def __eq__(self, other: object) -> bool:
        if not isinstance(other, JustHashable):
            return NotImplemented
        return self.value == other.value

# process_ordered_hashable(JustHashable(5))
# 上面的代码会在静态类型检查时报错，因为JustHashable没有实现__lt__和__gt__