深入理解 Maybe Monad：概念、Python 实现与挑战

from typing import Callable, TypeVar, Generic, Union

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

class Just(Generic[T]):
    """
    表示 Maybe Monad 中包含值的状态。
    """
    def __init__(self, value: T):
        if value is None:
            # 按照惯例，Just 不应该包含 None
            raise ValueError("Just cannot contain a None value. Use Nothing instead.")
        self.value = value

    def __repr__(self) -> str:
        return f'Just({self.value!r})'

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

class Nothing:
    """
    表示 Maybe Monad 中不包含值的状态。
    实现为单例模式，因为所有 Nothing 实例都是等价的。
    """
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Nothing, cls).__new__(cls)
        return cls._instance

    def __repr__(self) -> str:
        return 'Nothing'

    def __eq__(self, other: object) -> bool:
        return isinstance(other, Nothing)

# 定义 Maybe 类型为 Just[T] 或 Nothing 的联合
Maybe = Union[Just[T], Nothing]

def bind(f: Callable[[U], Maybe[T]], x: Maybe[U]) -> Maybe[T]:
    """
    Maybe Monad 的 bind 操作。
    接受一个 Maybe 值 x 和一个函数 f。
    如果 x 是 Just，则解包其值，应用 f，并返回结果。
    如果 x 是 Nothing，则直接返回 Nothing。
    """
    if isinstance(x, Just):
        return f(x.value)
    elif isinstance(x, Nothing):
        return x
    else:
        # 处理非 Maybe 类型输入的边界情况
        raise TypeError(f"Expected a Maybe type, got {type(x)}")

# --- 辅助函数：将普通函数提升到 Maybe 上下文 ---
def unit(value: T) -> Maybe[T]:
    """
    Maybe Monad 的 unit 操作（或 return）。
    将一个普通值封装到 Just 中。
    如果值为 None，则返回 Nothing。
    """
    if value is None:
        return Nothing()
    return Just(value)

# --- 示例用法 ---

# 1. 定义一些可能返回 Maybe 值的函数
def safe_divide(numerator: int, denominator: int) -> Maybe[float]:
    if denominator == 0:
        return Nothing()
    return Just(numerator / denominator)

def add_one(n: float) -> Maybe[float]:
    return Just(n + 1)

def multiply_by_two(n: float) -> Maybe[float]:
    return Just(n * 2)

# 2. 使用 bind 进行链式操作

# 成功路径
result_success = unit(10)  # Just(10)
result_success = bind(lambda x: safe_divide(x, 2), result_success) # Just(5.0)
result_success = bind(add_one, result_success) # Just(6.0)
result_success = bind(multiply_by_two, result_success) # Just(12.0)
print(f"成功路径结果: {result_success}") # 输出: 成功路径结果: Just(12.0)

# 失败路径 (除数为零)
result_failure_divide = unit(10)
result_failure_divide = bind(lambda x: safe_divide(x, 0), result_failure_divide) # Nothing
result_failure_divide = bind(add_one, result_failure_divide) # Nothing
print(f"失败路径结果 (除零): {result_failure_divide}") # 输出: 失败路径结果 (除零): Nothing

# 初始值为 Nothing
result_initial_nothing = Nothing()
result_initial_nothing = bind(add_one, result_initial_nothing) # Nothing
result_initial_nothing = bind(multiply_by_two, result_initial_nothing) # Nothing
print(f"初始 Nothing 结果: {result_initial_nothing}") # 输出: 初始 Nothing 结果: Nothing

# 3. 原始代码的改进点分析
# 原始代码中 `self.__class__ = Nothing if self.unit is None else Just` 的问题在于
# 它在原地修改了对象的类型，这不符合 Monad 返回新 Monad 实例的惯例，
# 且在 Python 中属于不推荐的动态类型修改行为。
# 正确的 Monad 实现应该始终返回一个新的 Monad 实例，而不是修改自身。
# 例如，在上面的 `bind` 函数中，我们总是返回 `f(x.value)` (一个新的 Just 或 Nothing)
# 或者直接返回 `x` (如果 x 是 Nothing，也是一个新的 Nothing 实例，因为 Nothing 是单例)。