理解Maybe Monad：Python中的实现与概念解析

from typing import Callable, TypeVar, Generic, Union

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

# Just类：表示存在一个值
class Just(Generic[T]):
    """
    Just类封装了一个非空值。
    """
    def __init__(self, value: T):
        if value is None:
            raise ValueError("Just cannot contain None. Use Nothing for absence.")
        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

# Nothing类：表示值的缺失，通常实现为单例
class Nothing:
    """
    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) 或缺失 (Nothing)
Maybe = Union[Just[T], Nothing]

# unit操作：将普通值封装为Maybe Monad
def unit(value: T) -> Maybe[T]:
    """
    Monad的unit操作，将一个普通值封装到Maybe Monad中。
    如果值为None，则返回Nothing；否则返回Just。
    """
    if value is None:
        return Nothing()
    return Just(value)

# bind操作：连接Monadic计算链
def bind(f: Callable[[U], T], x: Maybe[U]) -> Maybe[T]:
    """
    Monad的bind操作，将一个Maybe Monad值与一个函数组合。
    如果Maybe Monad是Nothing，则直接返回Nothing。
    如果Maybe Monad是Just，则将内部值传递给函数f，并将结果封装回Maybe Monad。
    """
    if isinstance(x, Nothing):
        return x
    elif isinstance(x, Just):
        # 调用函数f，并将其结果通过unit再次封装
        return unit(f(x.value))
    else:
        # 理论上Maybe类型检查会避免此情况，但作为防御性编程
        raise TypeError(f"Expected Maybe type, got {type(x)}")

# 示例函数
def add_one(n: int) -> int:
    return n + 1

def multiply_by_two(n: int) -> int:
    return n * 2

def get_length(s: str) -> int:
    return len(s)

# --- 示例用法 ---

# 1. 使用unit创建Maybe Monad
maybe_int_1 = unit(10)
maybe_int_none = unit(None)
maybe_str = unit("hello")

print(f"unit(10): {maybe_int_1}")         # Just(10)
print(f"unit(None): {maybe_int_none}")    # Nothing
print(f"unit('hello'): {maybe_str}")      # Just('hello')

# 2. 使用bind进行链式操作
result_1 = bind(add_one, maybe_int_1)
print(f"bind(add_one, Just(10)): {result_1}") # Just(11)

result_2 = bind(multiply_by_two, result_1)
print(f"bind(multiply_by_two, Just(11)): {result_2}") # Just(22)

# 3. bind操作中的空值传播
result_3 = bind(add_one, maybe_int_none)
print(f"bind(add_one, Nothing): {result_3}") # Nothing

# 链式调用，其中一个环节为Nothing，后续操作将短路
result_chain = bind(add_one, unit(5))
result_chain = bind(multiply_by_two, result_chain)
result_chain = bind(lambda x: None, result_chain) # 模拟一个操作返回None
result_chain = bind(add_one, result_chain)
print(f"Chain with None: {result_chain}") # Nothing

# 4. 类型不匹配的bind (在静态分析时会报错，运行时可能引发TypeError)
# bind(get_length, maybe_int_1) # Mypy会报错：Argument 1 to "bind" has incompatible type "Callable[[str], int]"; expected "Callable[[int], T]"

# 5. 模拟原始问题中的链式调用
# 初始值
m_a = unit(1)
print(f"m_a: {m_a}") # Just(1)

m_b = unit(1)
m_b = bind(add_one, m_b)
m_b = bind(add_one, m_b)
m_b = bind(add_one, m_b)
m_b = bind(add_one, m_b)
print(f"m_b (chained adds): {m_b}") # Just(5)

m_c = unit(None) # 初始为Nothing
m_c = bind(add_one, m_c)
m_c = bind(add_one, m_c)
m_c = bind(add_one, m_c)
print(f"m_c (chained adds from Nothing): {m_c}") # Nothing