Python类型检查：使用Result模式处理关联的Optional属性

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:
    return (result := compute(inputs)).success and result.data > 2

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:
        # 强制将 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:
    return (result := compute_simplified(inputs)).data is not None and result.data > 2

# 假设有多个数据字段
# success == all(d is not None for d in [data_x, data_y, data_z])
# 检查会变成：result.data_x is not None and result.data_y is not None and result.data_z is not None ...

@dataclass
class ResultWithProperty:
    data: Optional[int]

    @property
    def success(self) -> bool:
        return self.data is not None

def check_with_property(inputs: str) -> bool:
    return (result := compute_with_property(inputs)).success and result.data > 2

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

T = TypeVar('T')

@dataclass
class Success(Generic[T]): # 使用Generic来支持泛型
    data: T

class Fail:
    # Fail类不需要任何数据，表示操作失败
    pass

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

def compute_result(inputs: str) -> Result[int]:
    if inputs.startswith('!'):
        return Fail()
    return Success(len(inputs))

def check_with_result(inputs: str) -> bool:
    match compute_result(inputs):
        case Success(x): # 当匹配到Success时，x的类型被推断为int
            return x > 2
        case Fail():     # 当匹配到Fail时
            return False

# 示例验证
assert check_with_result('123')
assert not check_with_result('12')
assert not check_with_result('!123')

def is_success(r: Result[T]) -> bool:
    return isinstance(r, Success)

def map_result(result: Result[T], f: Callable[[T], U]) -> Result[U]:
    """
    如果Result是Success，则应用函数f并返回新的Success；否则返回Fail。
    """
    match result:
        case Success(x):
            return Success(f(x))
        case Fail():
            return Fail()

# 结合辅助函数进行操作
def check_with_map(inputs: str) -> bool:
    # 这种方式稍显复杂，但展示了函数式组合的可能性
    return is_success(map_result(compute_result(inputs), lambda data: data > 2))

# 组合多个Result
U = TypeVar('U')
V = TypeVar('V')

def map2_result(r0: Result[T], r1: Result[U], f: Callable[[T, U], V]) -> Result[V]:
    """
    如果两个Result都是Success，则应用二元函数f并返回新的Success；否则返回Fail。
    """
    match (r0, r1):
        case (Success(x0), Success(x1)):
            return Success(f(x0, x1))
        case _:
            return Fail()

@dataclass
class TwoThings:
    data0: int
    data1: int

def compute_another(inputs: str) -> Result[int]:
    if inputs.endswith('!'):
        return Fail()
    return Success(len(inputs) * 2)

# 组合两个计算结果
hopefully_two_things: Result[TwoThings] = map2_result(
    compute_result("foo"),
    compute_another("bar"),
    TwoThings
)

# 处理组合结果
match hopefully_two_things:
    case Success(data):
        print(f"Combined data: {data.data0}, {data.data1}")
    case Fail():
        print("One or both computations failed.")