from functools import singledispatch

# 1. 定義基礎(chǔ)泛型函數(shù)（為object類型注冊）
@singledispatch
def process_data(data, verbose=False):
    """處理數(shù)據(jù)的通用函數(shù)"""
    if verbose:
        print(f"Processing generic data: {type(data).__name__}")
    return str(data)

# 2. 注冊特定類型的實現(xiàn)（三種方式）
# 方式1：顯式指定類型
@process_data.register(int)
def _(data: int, verbose=False):
    if verbose:
        print(f"Processing integer: {data}")
    return data * 2

# 方式2：使用類型注解（Python 3.7+）
@process_data.register
def _(data: list, verbose=False):
    if verbose:
        print(f"Processing list with {len(data)} elements")
    return [x * 2 for x in data]

# 方式3：函數(shù)式注冊（支持lambda和已有函數(shù)）
process_data.register(float, lambda data, verbose=False: data * 3)

# 3. 注冊聯(lián)合類型（Python 3.11+）
from typing import Union
@process_data.register
def _(data: Union[tuple, set], verbose=False):
    if verbose:
        print(f"Processing collection: {type(data).__name__}")
    return list(data)

# 調(diào)用時自動根據(jù)第一個參數(shù)類型分派
print(process_data(42))                # 84 (int實現(xiàn))
print(process_data([1, 2, 3]))         # [2, 4, 6] (list實現(xiàn))
print(process_data(3.14))              # 9.42 (float實現(xiàn))
print(process_data("hello"))           # "hello" (默認(rèn)object實現(xiàn))
print(process_data((1, 2, 3)))         # [1, 2, 3] (Union實現(xiàn))

# 檢查分派行為
print(process_data.dispatch(list))     # <function _ at 0x...>
print(process_data.registry.keys())    # dict_keys([<class 'object'>, <class 'int'>, <class 'list'>, ...])

from collections.abc import Mapping

@singledispatch
def serialize(obj):
    return f"Generic: {obj}"

@serialize.register(Mapping)
def _(obj):
    return f"Mapping: {dict(obj)}"

# 字典會匹配Mapping實現(xiàn)，盡管未顯式注冊dict類型
print(serialize({"a": 1}))  # Mapping: {'a': 1}

def _dispatch(self, arg):
    cls = type(arg)
    
    # 1. 檢查緩存
    if cls in self._cache:
        return self._cache[cls]
    
    # 2. 生成擴(kuò)展MRO（包含ABC）
    mro = self._get_extended_mro(cls)
    
    # 3. 查找最佳匹配
    for typ in mro:
        if typ in self._registry:
            self._cache[cls] = self._registry[typ]
            return self._registry[typ]
    
    # 4. 兜底（理論上不會觸發(fā)，因為注冊了object類型）
    return self._registry[object]

def _get_extended_mro(self, cls):
    # 生成包含ABC的擴(kuò)展MRO
    mro = list(cls.__mro__)
    abc_list = []
    
    # 收集所有相關(guān)ABC
    for abc in self._registry:
        if abc is not object and issubclass(cls, abc):
            abc_list.append(abc)
    
    # 排序并去重，確保正確的繼承順序
    abc_list = sorted(abc_list, key=lambda x: len(x.__mro__), reverse=True)
    extended_mro = []
    for typ in mro:
        extended_mro.append(typ)
        # 插入相關(guān)ABC到對應(yīng)位置
        for abc in abc_list:
            if issubclass(typ, abc) and not any(issubclass(base, abc) for base in typ.__bases__):
                extended_mro.append(abc)
    
    return list(dict.fromkeys(extended_mro))  # 去重保持順序

from collections.abc import Iterable, Container

class P:
    pass

Iterable.register(P)
Container.register(P)

@singledispatch
def g(obj):
    return "base"

g.register(Iterable, lambda obj: "iterable")
g.register(Container, lambda obj: "container")

# 以下調(diào)用會拋出RuntimeError: Ambiguous dispatch
# print(g(P()))

def process_data(data):
    if isinstance(data, int):
        return data * 2
    elif isinstance(data, str):
        return data.upper()
    elif isinstance(data, list):
        return [x * 2 for x in data]
    else:
        return str(data)

@singledispatch
def process_data(data):
    return str(data)

@process_data.register(int)
def _(data):
    return data * 2

@process_data.register(str)
def _(data):
    return data.upper()

@process_data.register(list)
def _(data):
    return [x * 2 for x in data]

@singledispatch
def serialize(obj):
    """通用序列化函數(shù)"""
    raise TypeError(f"Unsupported type: {type(obj)}")

@serialize.register(int)
@serialize.register(float)
def _(obj):
    return {"type": type(obj).__name__, "value": obj}

@serialize.register(str)
def _(obj):
    return {"type": "str", "value": obj}

@serialize.register(list)
def _(obj):
    return {"type": "list", "value": [serialize(item) for item in obj]}

# 輕松擴(kuò)展自定義類型
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

@serialize.register(Person)
def _(obj):
    return {"type": "Person", "name": obj.name, "age": obj.age}

from flask import jsonify

@singledispatch
def format_response(data):
    """格式化API響應(yīng)"""
    return jsonify({"status": "success", "data": str(data)})

@format_response.register(dict)
def _(data):
    return jsonify({"status": "success", **data})

@format_response.register(list)
def _(data):
    return jsonify({
        "status": "success",
        "count": len(data),
        "data": data
    })

@format_response.register(Exception)
def _(data):
    return jsonify({
        "status": "error",
        "message": str(data)
    }), 500

from functools import singledispatchmethod

class DataProcessor:
    @singledispatchmethod
    def process(self, data):
        raise NotImplementedError(f"Unsupported type: {type(data)}")
    
    @process.register
    def _(self, data: int):
        return data * 2
    
    @process.register
    def _(self, data: str):
        return data.upper()
    
    @process.register
    def _(self, data: list):
        return [self.process(item) for item in data]

processor = DataProcessor()
print(processor.process(42))       # 84
print(processor.process([1, "abc"]))  # [2, "ABC"]