Python实现简单的Rust风格类型检查

# 基本类型提示
def add(a: int, b: int) -> int:
    return a + b
# 列表类型提示
from typing import List
def process_numbers(numbers: List[int]) -> List[int]:
    return [n * 2 for n in numbers]
# 字典类型提示
from typing import Dict
def get_user_info(user_id: int) -> Dict[str, str]:
    return {"id": str(user_id), "name": "张三"}

# 安装mypy
pip install mypy
# 检查代码
mypy your_code.py

from typing import get_type_hints, Union
import inspect
def type_check(func):
    """类型检查装饰器"""
    def wrapper(*args, **kwargs):
        # 获取函数的类型提示
        type_hints = get_type_hints(func)
        # 检查位置参数
        sig = inspect.signature(func)
        params = list(sig.parameters.values())
        # 检查位置参数类型
        for i, (param_name, arg_value) in enumerate(zip(params, args)):
            if param_name in type_hints:
                expected_type = type_hints[param_name]
                if not isinstance(arg_value, expected_type):
                    raise TypeError(f"参数 {param_name} 期望类型 {expected_type}，实际类型 {type(arg_value)}")
        # 检查关键字参数类型
        for param_name, arg_value in kwargs.items():
            if param_name in type_hints:
                expected_type = type_hints[param_name]
                if not isinstance(arg_value, expected_type):
                    raise TypeError(f"参数 {param_name} 期望类型 {expected_type}，实际类型 {type(arg_value)}")
        # 执行函数
        result = func(*args, **kwargs)
        # 检查返回值类型
        if 'return' in type_hints:
            expected_return_type = type_hints['return']
            if not isinstance(result, expected_return_type):
                raise TypeError(f"返回值期望类型 {expected_return_type}，实际类型 {type(result)}")
        return result
    return wrapper
# 使用装饰器
@type_check
def add(a: int, b: int) -> int:
    return a + b
# 测试
print(add(1, 2))  # 正常运行
print(add(1, "2"))  # 抛出类型错误

from typing import get_type_hints, Union, List, Dict, Optional, TypeVar, Generic
import inspect
import typing
T = TypeVar('T')
class TypeChecker:
    """类型检查器"""
    @staticmethod
    def is_instance(obj, expected_type):
        """检查对象是否符合期望类型"""
        # 处理基本类型
        if isinstance(expected_type, type):
            return isinstance(obj, expected_type)
        # 处理Union类型
        if getattr(expected_type, '__origin__', None) is Union:
            return any(TypeChecker.is_instance(obj, arg) for arg in expected_type.__args__)
        # 处理List类型
        if getattr(expected_type, '__origin__', None) is list or getattr(expected_type, '__origin__', None) is List:
            if not isinstance(obj, list):
                return False
            item_type = expected_type.__args__[0]
            return all(TypeChecker.is_instance(item, item_type) for item in obj)
        # 处理Dict类型
        if getattr(expected_type, '__origin__', None) is dict or getattr(expected_type, '__origin__', None) is Dict:
            if not isinstance(obj, dict):
                return False
            key_type, value_type = expected_type.__args__
            return all(
                TypeChecker.is_instance(key, key_type) and TypeChecker.is_instance(value, value_type)
                for key, value in obj.items()
            )
        # 处理Optional类型
        if getattr(expected_type, '__origin__', None) is Optional:
            if obj is None:
                return True
            return TypeChecker.is_instance(obj, expected_type.__args__[0])
        return True
def type_check(func):
    """类型检查装饰器"""
    def wrapper(*args, **kwargs):
        # 获取函数的类型提示
        type_hints = get_type_hints(func)
        # 检查位置参数
        sig = inspect.signature(func)
        params = list(sig.parameters.values())
        # 检查位置参数类型
        for i, (param_name, arg_value) in enumerate(zip(params, args)):
            if param_name in type_hints:
                expected_type = type_hints[param_name]
                if not TypeChecker.is_instance(arg_value, expected_type):
                    raise TypeError(f"参数 {param_name} 期望类型 {expected_type}，实际类型 {type(arg_value)}")
        # 检查关键字参数类型
        for param_name, arg_value in kwargs.items():
            if param_name in type_hints:
                expected_type = type_hints[param_name]
                if not TypeChecker.is_instance(arg_value, expected_type):
                    raise TypeError(f"参数 {param_name} 期望类型 {expected_type}，实际类型 {type(arg_value)}")
        # 执行函数
        result = func(*args, **kwargs)
        # 检查返回值类型
        if 'return' in type_hints:
            expected_return_type = type_hints['return']
            if not TypeChecker.is_instance(result, expected_return_type):
                raise TypeError(f"返回值期望类型 {expected_return_type}，实际类型 {type(result)}")
        return result
    return wrapper
# 使用装饰器
@type_check
def process_data(data: List[int]) -> Dict[str, Union[int, str]]:
    return {
        "sum": sum(data),
        "count": len(data),
        "status": "success"
    }
# 测试
print(process_data([1, 2, 3]))  # 正常运行
print(process_data([1, "2", 3]))  # 抛出类型错误

enum Result<T, E> {
    Ok(T),
    Err(E),
}

from typing import Generic, TypeVar, Union, Optional
T = TypeVar('T')
E = TypeVar('E')
class Result(Generic[T, E]):
    """Rust风格的Result类型"""
    def __init__(self, value: Union[T, E], is_ok: bool):
        self.value = value
        self._is_ok = is_ok
    @classmethod
    def ok(cls, value: T) -> 'Result[T, E]':
        """创建成功的Result"""
        return cls(value, True)
    @classmethod
    def err(cls, error: E) -> 'Result[T, E]':
        """创建失败的Result"""
        return cls(error, False)
    def is_ok(self) -> bool:
        """检查是否成功"""
        return self._is_ok
    def is_err(self) -> bool:
        """检查是否失败"""
        return not self._is_ok
    def unwrap(self) -> T:
        """获取成功值，如果失败则抛出异常"""
        if self.is_ok():
            return self.value
        raise ValueError(f"Result is Err: {self.value}")
    def unwrap_err(self) -> E:
        """获取错误值，如果成功则抛出异常"""
        if self.is_err():
            return self.value
        raise ValueError("Result is Ok")
    def unwrap_or(self, default: T) -> T:
        """获取成功值，如果失败则返回默认值"""
        if self.is_ok():
            return self.value
        return default
# 使用Result类型
def divide(a: int, b: int) -> Result[int, str]:
    if b == 0:
        return Result.err("除数不能为零")
    return Result.ok(a // b)
# 测试
result = divide(10, 2)
if result.is_ok():
    print(f"结果: {result.unwrap()}")
else:
    print(f"错误: {result.unwrap_err()}")
result = divide(10, 0)
if result.is_ok():
    print(f"结果: {result.unwrap()}")
else:
    print(f"错误: {result.unwrap_err()}")

enum Option<T> {
    Some(T),
    None,
}

from typing import Generic, TypeVar, Optional
T = TypeVar('T')
class Option(Generic[T]):
    """Rust风格的Option类型"""
    def __init__(self, value: Optional[T], is_some: bool):
        self.value = value
        self._is_some = is_some
    @classmethod
    def some(cls, value: T) -> 'Option[T]':
        """创建有值的Option"""
        return cls(value, True)
    @classmethod
    def none(cls) -> 'Option[T]':
        """创建无值的Option"""
        return cls(None, False)
    def is_some(self) -> bool:
        """检查是否有值"""
        return self._is_some
    def is_none(self) -> bool:
        """检查是否无值"""
        return not self._is_some
    def unwrap(self) -> T:
        """获取值，如果无值则抛出异常"""
        if self.is_some():
            return self.value
        raise ValueError("Option is None")
    def unwrap_or(self, default: T) -> T:
        """获取值，如果无值则返回默认值"""
        if self.is_some():
            return self.value
        return default
# 使用Option类型
def find_user(user_id: int) -> Option[dict]:
    users = {1: {"id": 1, "name": "张三"}, 2: {"id": 2, "name": "李四"}}
    if user_id in users:
        return Option.some(users[user_id])
    return Option.none()
# 测试
user = find_user(1)
if user.is_some():
    print(f"用户: {user.unwrap()}")
else:
    print("用户不存在")
user = find_user(3)
if user.is_some():
    print(f"用户: {user.unwrap()}")
else:
    print("用户不存在")