Python类型检查：优化关联可选属性的Mypy推断策略

from dataclasses import dataclass
from typing import Optional

@dataclass
class Result:
    success: bool
    data: Optional[int]  # 当 success 为 True 时，data 保证不为 None。

def compute(inputs: str) -> Result:
    if inputs.startswith('!'):
        return Result(success=False, data=None)
    return Result(success=True, data=len(inputs))

def check(inputs: str) -> bool:
    result = compute(inputs)
    # 即使我们检查了 result.success，Mypy 也无法推断 result.data 此时为 int
    return result.success and result.data > 2

# 运行 mypy 会报告错误：
# test.py:18: error: Unsupported operand types for < ("int" and "None")  [operator]
# test.py:18: note: Left operand is of type "Optional[int]"

from typing import cast

def check_with_cast(inputs: str) -> bool:
    result = compute(inputs)
    if result.success:
        # 强制 Mypy 相信 result.data 是 int
        return cast(int, result.data) > 2
    return False

@dataclass
class ResultSimplified:
    data: Optional[int]

def compute_simplified(inputs: str) -> ResultSimplified:
    if inputs.startswith('!'):
        return ResultSimplified(data=None)
    return ResultSimplified(data=len(inputs))

def check_simplified(inputs: str) -> bool:
    result = compute_simplified(inputs)
    # Mypy 可以正确推断 data 在此分支中为 int
    return result.data is not None and result.data > 2

from dataclasses import dataclass
from typing import TypeVar, Union, Callable

# 定义一个类型变量，用于泛型 Success 类
T = TypeVar('T')

@dataclass
class Success(T): # 注意：这里 T 应该作为泛型参数，而不是基类
    data: T

class Fail:
    """表示计算失败的类型，不包含任何数据"""
    pass

# 定义 Result 类型为 Success[T] 和 Fail 的联合
Result = Union[Success[T], Fail]

# 修正 Success 类的定义，使其正确地使用泛型
@dataclass
class SuccessGeneric[T]:
    data: T

class Fail:
    pass

ResultGeneric[T] = Union[SuccessGeneric[T], Fail]

# 修正 compute 函数以返回新的 ResultGeneric 类型
def compute_adt(inputs: str) -> ResultGeneric[int]:
    if inputs.startswith('!'):
        return Fail()
    return SuccessGeneric(len(inputs))

# 使用 match 语句处理 ResultGeneric 类型
def check_adt(inputs: str) -> bool:
    match compute_adt(inputs):
        case SuccessGeneric(x): # 当匹配到 SuccessGeneric 时，x 的类型被 Mypy 推断为 int
            return x > 2
        case Fail(): # 匹配到 Fail 时，不进行数据操作
            return False

# 示例断言
assert check_adt('123')
assert not check_adt('12')
assert not check_adt('!123')

# 判断 ResultGeneric 是否为 Success
def is_success[T](r: ResultGeneric[T]) -> bool:
    return isinstance(r, SuccessGeneric)

# 对 Success 中的数据进行映射转换
def map_result[T, U](result: ResultGeneric[T], f: Callable[[T], U]) -> ResultGeneric[U]:
    match result:
        case SuccessGeneric(x):
            return SuccessGeneric(f(x))
        case Fail():
            return Fail()

# 结合多个 ResultGeneric，只有当所有 ResultGeneric 都成功时才执行函数
def map2_result[T, U, V](r0: ResultGeneric[T], r1: ResultGeneric[U], f: Callable[[T, U], V]) -> ResultGeneric[V]:
    match (r0, r1):
        case (SuccessGeneric(x0), SuccessGeneric(x1)):
            return SuccessGeneric(f(x0, x1))
        case _: # 任意一个失败则返回 Fail
            return Fail()

# 示例：使用 map_result
def check_with_map(inputs: str) -> bool:
    # 映射操作返回 ResultGeneric[bool]，然后判断是否为 Success
    return is_success(map_result(compute_adt(inputs), lambda data: data > 2))

# 示例：结合多个 ResultGeneric
@dataclass
class TwoThings:
    data0: int
    data1: int

def compute_multiple_things(s0: str, s1: str) -> ResultGeneric[TwoThings]:
    return map2_result(compute_adt(s0), compute_adt(s1), TwoThings)

# 调用示例
multiple_result = compute_multiple_things("foo", "bar")
if is_success(multiple_result):
    print(f"成功获取两个数据: {multiple_result.data.data0}, {multiple_result.data.data1}")
else:
    print("至少一个计算失败")